feat: v2 organizations event types endpoints (#15775)

* fix: event-types input service transform length property

* feat: create organizations event-types controller, service and repository

* feat: enable organizations event types

* fix: create team request user isOrgAdmin check

* refactor: hosts array required in team input and output

* chore: use platform-libraries at version 0.0.19

* tests: test organizations event-types

* feat: enable managed event-types

* chore: fix main merge into this branch

* feat: assign all team members for managed event-types

* refactor: gathering managed event-type users ids

* chore: include assignAllTeamMembers in team event response

* test: assign all team members db event

* chore: delete unused files

* docs: swagger create and update request body objects

* revert: event-types platform-libraries update

* refactor: organisations event-types endpoints accessible by TEAM_ADMIN and up

* fix: managed event types output hosts array empty

* fix: dont allow creating event-type for non-team member

* chore: delete unused variables

* tests: negative tests

* chore: finish main merge

apps/api/v2/package.json

@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@calcom/platform-constants": "*",
-    "@calcom/platform-libraries-0.0.18": "npm:@calcom/platform-libraries@0.0.18",
+    "@calcom/platform-libraries-0.0.19": "npm:@calcom/platform-libraries@0.0.19",
     "@calcom/platform-libraries-0.0.2": "npm:@calcom/platform-libraries@0.0.2",
     "@calcom/platform-types": "*",
     "@calcom/platform-utils": "*",

apps/api/v2/src/ee/bookings/controllers/bookings.controller.e2e-spec.ts

@@ -19,7 +19,7 @@ import { UserRepositoryFixture } from "test/fixtures/repository/users.repository
 import { withApiAuth } from "test/utils/withApiAuth";
 
 import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";
-import { handleNewBooking } from "@calcom/platform-libraries-0.0.18";
+import { handleNewBooking } from "@calcom/platform-libraries-0.0.19";
 import { ApiSuccessResponse, ApiResponse } from "@calcom/platform-types";
 
 describe("Bookings Endpoints", () => {

apps/api/v2/src/ee/bookings/controllers/bookings.controller.ts

@@ -46,7 +46,7 @@ import {
   getBookingInfo,
   handleCancelBooking,
   getBookingForReschedule,
-} from "@calcom/platform-libraries-0.0.18";
+} from "@calcom/platform-libraries-0.0.19";
 import { GetBookingsInput, CancelBookingInput, Status } from "@calcom/platform-types";
 import { ApiResponse } from "@calcom/platform-types";
 import { PrismaClient } from "@calcom/prisma";

apps/api/v2/src/ee/bookings/inputs/create-recurring-booking.input.ts

@@ -1,7 +1,7 @@
 import { CreateBookingInput } from "@/ee/bookings/inputs/create-booking.input";
 import { IsBoolean, IsNumber, IsOptional } from "class-validator";
 
-import type { AppsStatus } from "@calcom/platform-libraries-0.0.18";
+import type { AppsStatus } from "@calcom/platform-libraries-0.0.19";
 
 export class CreateRecurringBookingInput extends CreateBookingInput {
   @IsBoolean()

apps/api/v2/src/ee/calendars/services/apple-calendar.service.ts

@@ -5,7 +5,7 @@ import { BadRequestException, UnauthorizedException } from "@nestjs/common";
 import { Injectable } from "@nestjs/common";
 
 import { SUCCESS_STATUS, APPLE_CALENDAR_TYPE, APPLE_CALENDAR_ID } from "@calcom/platform-constants";
-import { symmetricEncrypt, CalendarService } from "@calcom/platform-libraries-0.0.18";
+import { symmetricEncrypt, CalendarService } from "@calcom/platform-libraries-0.0.19";
 
 @Injectable()
 export class AppleCalendarService implements CredentialSyncCalendarApp {

apps/api/v2/src/ee/calendars/services/calendars.service.ts

@@ -17,7 +17,7 @@ import { User } from "@prisma/client";
 import { DateTime } from "luxon";
 import { z } from "zod";
 
-import { getConnectedDestinationCalendars, getBusyCalendarTimes } from "@calcom/platform-libraries-0.0.18";
+import { getConnectedDestinationCalendars, getBusyCalendarTimes } from "@calcom/platform-libraries-0.0.19";
 import { Calendar } from "@calcom/platform-types";
 import { PrismaClient } from "@calcom/prisma";
 

apps/api/v2/src/ee/event-types/event-types_2024_04_15/controllers/event-types.controller.e2e-spec.ts

@@ -35,7 +35,7 @@ import {
   EventTypesPublic,
   eventTypeBookingFields,
   eventTypeLocations,
-} from "@calcom/platform-libraries-0.0.18";
+} from "@calcom/platform-libraries-0.0.19";
 import { ApiSuccessResponse } from "@calcom/platform-types";
 
 describe("Event types Endpoints", () => {

apps/api/v2/src/ee/event-types/event-types_2024_04_15/event-types.repository.ts

@@ -4,7 +4,7 @@ import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { UserWithProfile } from "@/modules/users/users.repository";
 import { Injectable } from "@nestjs/common";
 
-import { getEventTypeById } from "@calcom/platform-libraries-0.0.18";
+import { getEventTypeById } from "@calcom/platform-libraries-0.0.19";
 import type { PrismaClient } from "@calcom/prisma";
 
 @Injectable()

apps/api/v2/src/ee/event-types/event-types_2024_04_15/services/event-types.service.ts

@@ -14,7 +14,7 @@ import {
   updateEventType,
   EventTypesPublic,
   getEventTypesPublic,
-} from "@calcom/platform-libraries-0.0.18";
+} from "@calcom/platform-libraries-0.0.19";
 import { EventType } from "@calcom/prisma/client";
 
 @Injectable()

apps/api/v2/src/ee/event-types/event-types_2024_06_14/event-types.module.ts

@@ -22,6 +22,11 @@ import { Module } from "@nestjs/common";
     UsersService,
   ],
   controllers: [EventTypesController_2024_06_14],
-  exports: [EventTypesService_2024_06_14, EventTypesRepository_2024_06_14],
+  exports: [
+    EventTypesService_2024_06_14,
+    EventTypesRepository_2024_06_14,
+    InputEventTypesService_2024_06_14,
+    OutputEventTypesService_2024_06_14,
+  ],
 })
 export class EventTypesModule_2024_06_14 {}

apps/api/v2/src/ee/event-types/event-types_2024_06_14/event-types.repository.ts

@@ -7,7 +7,7 @@ import {
   getEventTypeById,
   transformApiEventTypeBookingFields,
   transformApiEventTypeLocations,
-} from "@calcom/platform-libraries-0.0.18";
+} from "@calcom/platform-libraries-0.0.19";
 import { CreateEventTypeInput_2024_06_14 } from "@calcom/platform-types";
 import type { PrismaClient } from "@calcom/prisma";
 

apps/api/v2/src/ee/event-types/event-types_2024_06_14/services/event-types.service.ts

@@ -9,9 +9,9 @@ import { UsersService } from "@/modules/users/services/users.service";
 import { UserWithProfile, UsersRepository } from "@/modules/users/users.repository";
 import { BadRequestException, ForbiddenException, Injectable, NotFoundException } from "@nestjs/common";
 
-import { createEventType, updateEventType } from "@calcom/platform-libraries-0.0.18";
-import { getEventTypesPublic, EventTypesPublic } from "@calcom/platform-libraries-0.0.18";
-import { dynamicEvent } from "@calcom/platform-libraries-0.0.18";
+import { createEventType, updateEventType } from "@calcom/platform-libraries-0.0.19";
+import { getEventTypesPublic, EventTypesPublic } from "@calcom/platform-libraries-0.0.19";
+import { dynamicEvent } from "@calcom/platform-libraries-0.0.19";
 import {
   CreateEventTypeInput_2024_06_14,
   UpdateEventTypeInput_2024_06_14,

apps/api/v2/src/ee/event-types/event-types_2024_06_14/services/input-event-types.service.ts

@@ -3,7 +3,7 @@ import { Injectable } from "@nestjs/common";
 import {
   transformApiEventTypeBookingFields,
   transformApiEventTypeLocations,
-} from "@calcom/platform-libraries-0.0.18";
+} from "@calcom/platform-libraries-0.0.19";
 import { CreateEventTypeInput_2024_06_14, UpdateEventTypeInput_2024_06_14 } from "@calcom/platform-types";
 
 @Injectable()
@@ -29,10 +29,11 @@ export class InputEventTypesService_2024_06_14 {
   }
 
   transformInputUpdateEventType(inputEventType: UpdateEventTypeInput_2024_06_14) {
-    const { locations, bookingFields, ...rest } = inputEventType;
+    const { lengthInMinutes, locations, bookingFields, ...rest } = inputEventType;
 
     const eventType = {
       ...rest,
+      length: lengthInMinutes,
       locations: locations ? this.transformInputLocations(locations) : undefined,
       bookingFields: bookingFields ? this.transformInputBookingFields(bookingFields) : undefined,
     };

apps/api/v2/src/ee/event-types/event-types_2024_06_14/services/output-event-types.service.ts

@@ -9,7 +9,7 @@ import {
   parseRecurringEvent,
   TransformedLocationsSchema,
   BookingFieldsSchema,
-} from "@calcom/platform-libraries-0.0.18";
+} from "@calcom/platform-libraries-0.0.19";
 
 type EventTypeRelations = { users: User[]; schedule: Schedule | null };
 type DatabaseEventType = EventType & EventTypeRelations;

apps/api/v2/src/ee/schedules/schedules_2024_06_11/services/input-schedules.service.ts

@@ -3,7 +3,7 @@ import { Injectable } from "@nestjs/common";
 import {
   transformApiScheduleOverrides,
   transformApiScheduleAvailability,
-} from "@calcom/platform-libraries-0.0.18";
+} from "@calcom/platform-libraries-0.0.19";
 import { CreateScheduleInput_2024_06_11, ScheduleAvailabilityInput_2024_06_11 } from "@calcom/platform-types";
 import { ScheduleOverrideInput_2024_06_11 } from "@calcom/platform-types";
 

apps/api/v2/src/filters/trpc-exception.filter.ts

@@ -2,7 +2,7 @@ import { ArgumentsHost, Catch, ExceptionFilter, Logger } from "@nestjs/common";
 import { Request } from "express";
 
 import { ERROR_STATUS } from "@calcom/platform-constants";
-import { TRPCError } from "@calcom/platform-libraries-0.0.18";
+import { TRPCError } from "@calcom/platform-libraries-0.0.19";
 import { Response } from "@calcom/platform-types";
 
 @Catch(TRPCError)

apps/api/v2/src/modules/email/email.service.ts

@@ -1,7 +1,6 @@
-import { UserWithProfile } from "@/modules/users/users.repository";
 import { Injectable } from "@nestjs/common";
 
-import { sendSignupToOrganizationEmail, getTranslation } from "@calcom/platform-libraries-0.0.18";
+import { sendSignupToOrganizationEmail, getTranslation } from "@calcom/platform-libraries-0.0.19";
 
 @Injectable()
 export class EmailService {

apps/api/v2/src/modules/oauth-clients/services/oauth-clients-users.service.ts

@@ -7,7 +7,7 @@ import { UsersRepository } from "@/modules/users/users.repository";
 import { BadRequestException, Injectable } from "@nestjs/common";
 import { User } from "@prisma/client";
 
-import { createNewUsersConnectToOrgIfExists, slugify } from "@calcom/platform-libraries-0.0.18";
+import { createNewUsersConnectToOrgIfExists, slugify } from "@calcom/platform-libraries-0.0.19";
 
 @Injectable()
 export class OAuthClientUsersService {

apps/api/v2/src/modules/organizations/controllers/event-types/organizations-event-types.controller.ts

@@ -0,0 +1,156 @@
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
+import { Roles } from "@/modules/auth/decorators/roles/roles.decorator";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import { IsOrgGuard } from "@/modules/auth/guards/organizations/is-org.guard";
+import { RolesGuard } from "@/modules/auth/guards/roles/roles.guard";
+import { IsTeamInOrg } from "@/modules/auth/guards/teams/is-team-in-org.guard";
+import { CreateTeamEventTypeOutput } from "@/modules/organizations/controllers/event-types/outputs/teams/create-team-event-type.output";
+import { DeleteTeamEventTypeOutput } from "@/modules/organizations/controllers/event-types/outputs/teams/delete-team-event-type.output";
+import { GetTeamEventTypeOutput } from "@/modules/organizations/controllers/event-types/outputs/teams/get-team-event-type.output";
+import { GetTeamEventTypesOutput } from "@/modules/organizations/controllers/event-types/outputs/teams/get-team-event-types.output";
+import { UpdateTeamEventTypeOutput } from "@/modules/organizations/controllers/event-types/outputs/teams/update-team-event-type.output";
+import { OrganizationsEventTypesService } from "@/modules/organizations/services/event-types/organizations-event-types.service";
+import { UserWithProfile } from "@/modules/users/users.repository";
+import {
+  Controller,
+  UseGuards,
+  Get,
+  Post,
+  Param,
+  ParseIntPipe,
+  Body,
+  Patch,
+  Delete,
+  HttpCode,
+  HttpStatus,
+  NotFoundException,
+  Query,
+} from "@nestjs/common";
+import { ApiTags as DocsTags } from "@nestjs/swagger";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import {
+  CreateTeamEventTypeInput_2024_06_14,
+  SkipTakePagination,
+  UpdateTeamEventTypeInput_2024_06_14,
+} from "@calcom/platform-types";
+
+@Controller({
+  path: "/v2/organizations/:orgId",
+  version: API_VERSIONS_VALUES,
+})
+@UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard)
+@DocsTags("Organizations Event Types")
+export class OrganizationsEventTypesController {
+  constructor(private readonly organizationsEventTypesService: OrganizationsEventTypesService) {}
+
+  @Roles("TEAM_ADMIN")
+  @UseGuards(IsTeamInOrg)
+  @Post("/teams/:teamId/event-types")
+  async createTeamEventType(
+    @GetUser() user: UserWithProfile,
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Body() bodyEventType: CreateTeamEventTypeInput_2024_06_14
+  ): Promise<CreateTeamEventTypeOutput> {
+    const eventType = await this.organizationsEventTypesService.createTeamEventType(
+      user,
+      teamId,
+      orgId,
+      bodyEventType
+    );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: eventType,
+    };
+  }
+
+  @Roles("TEAM_ADMIN")
+  @UseGuards(IsTeamInOrg)
+  @Get("/teams/:teamId/event-types/:eventTypeId")
+  async getTeamEventType(
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("eventTypeId") eventTypeId: number
+  ): Promise<GetTeamEventTypeOutput> {
+    const eventType = await this.organizationsEventTypesService.getTeamEventType(teamId, eventTypeId);
+
+    if (!eventType) {
+      throw new NotFoundException(`Event type with id ${eventTypeId} not found`);
+    }
+
+    return {
+      status: SUCCESS_STATUS,
+      data: eventType,
+    };
+  }
+
+  @Roles("TEAM_ADMIN")
+  @UseGuards(IsTeamInOrg)
+  @Get("/teams/:teamId/event-types")
+  async getTeamEventTypes(@Param("teamId", ParseIntPipe) teamId: number): Promise<GetTeamEventTypesOutput> {
+    const eventTypes = await this.organizationsEventTypesService.getTeamEventTypes(teamId);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: eventTypes,
+    };
+  }
+
+  @Roles("TEAM_ADMIN")
+  @Get("/teams/event-types")
+  async getTeamsEventTypes(
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Query() queryParams: SkipTakePagination
+  ): Promise<GetTeamEventTypesOutput> {
+    const { skip, take } = queryParams;
+    const eventTypes = await this.organizationsEventTypesService.getTeamsEventTypes(orgId, skip, take);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: eventTypes,
+    };
+  }
+
+  @Roles("TEAM_ADMIN")
+  @UseGuards(IsTeamInOrg)
+  @Patch("/teams/:teamId/event-types/:eventTypeId")
+  async updateTeamEventType(
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("eventTypeId") eventTypeId: number,
+    @GetUser() user: UserWithProfile,
+    @Body() bodyEventType: UpdateTeamEventTypeInput_2024_06_14
+  ): Promise<UpdateTeamEventTypeOutput> {
+    const eventType = await this.organizationsEventTypesService.updateTeamEventType(
+      eventTypeId,
+      teamId,
+      bodyEventType,
+      user
+    );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: eventType,
+    };
+  }
+
+  @Roles("TEAM_ADMIN")
+  @UseGuards(IsTeamInOrg)
+  @Delete("/teams/:teamId/event-types/:eventTypeId")
+  @HttpCode(HttpStatus.OK)
+  async deleteTeamEventType(
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("eventTypeId") eventTypeId: number
+  ): Promise<DeleteTeamEventTypeOutput> {
+    const eventType = await this.organizationsEventTypesService.deleteTeamEventType(teamId, eventTypeId);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: {
+        id: eventTypeId,
+        title: eventType.title,
+      },
+    };
+  }
+}

apps/api/v2/src/modules/organizations/controllers/event-types/organizations-event-types.e2e-spec.ts

@@ -0,0 +1,595 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { TokensModule } from "@/modules/tokens/tokens.module";
+import { UsersModule } from "@/modules/users/users.module";
+import { INestApplication } from "@nestjs/common";
+import { NestExpressApplication } from "@nestjs/platform-express";
+import { Test } from "@nestjs/testing";
+import { User } from "@prisma/client";
+import * as request from "supertest";
+import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
+import { MembershipRepositoryFixture } from "test/fixtures/repository/membership.repository.fixture";
+import { ProfileRepositoryFixture } from "test/fixtures/repository/profiles.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { withApiAuth } from "test/utils/withApiAuth";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import {
+  ApiSuccessResponse,
+  CreateTeamEventTypeInput_2024_06_14,
+  Host,
+  TeamEventTypeOutput_2024_06_14,
+  UpdateTeamEventTypeInput_2024_06_14,
+} from "@calcom/platform-types";
+import { Team } from "@calcom/prisma/client";
+
+describe("Organizations Event Types Endpoints", () => {
+  describe("User Authentication - User is Org Admin", () => {
+    let app: INestApplication;
+
+    let userRepositoryFixture: UserRepositoryFixture;
+    let organizationsRepositoryFixture: TeamRepositoryFixture;
+    let teamsRepositoryFixture: TeamRepositoryFixture;
+    let membershipsRepositoryFixture: MembershipRepositoryFixture;
+    let profileRepositoryFixture: ProfileRepositoryFixture;
+    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+
+    let org: Team;
+    let team: Team;
+    let falseTestOrg: Team;
+    let falseTestTeam: Team;
+
+    const userEmail = "org-admin-event-types-controller-e222e@api.com";
+    let userAdmin: User;
+
+    const teammate1Email = "teammate111@team.com";
+    const teammate2Email = "teammate221@team.com";
+    const falseTestUserEmail = "false-user@false-team.com";
+    let teammate1: User;
+    let teammate2: User;
+    let falseTestUser: User;
+
+    let collectiveEventType: TeamEventTypeOutput_2024_06_14;
+    let managedEventType: TeamEventTypeOutput_2024_06_14;
+
+    beforeAll(async () => {
+      const moduleRef = await withApiAuth(
+        userEmail,
+        Test.createTestingModule({
+          imports: [AppModule, PrismaModule, UsersModule, TokensModule],
+        })
+      ).compile();
+
+      userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+      organizationsRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      teamsRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+      profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
+      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+
+      userAdmin = await userRepositoryFixture.create({
+        email: userEmail,
+        username: userEmail,
+        role: "ADMIN",
+      });
+
+      teammate1 = await userRepositoryFixture.create({
+        email: teammate1Email,
+        username: teammate1Email,
+      });
+
+      teammate2 = await userRepositoryFixture.create({
+        email: teammate2Email,
+        username: teammate2Email,
+      });
+
+      falseTestUser = await userRepositoryFixture.create({
+        email: falseTestUserEmail,
+        username: falseTestUserEmail,
+      });
+
+      org = await organizationsRepositoryFixture.create({
+        name: "Test Organization",
+        isOrganization: true,
+      });
+
+      falseTestOrg = await organizationsRepositoryFixture.create({
+        name: "False test org",
+        isOrganization: true,
+      });
+
+      team = await teamsRepositoryFixture.create({
+        name: "Test org team",
+        isOrganization: false,
+        parent: { connect: { id: org.id } },
+      });
+
+      falseTestTeam = await teamsRepositoryFixture.create({
+        name: "Outside org team",
+        isOrganization: false,
+        parent: { connect: { id: falseTestOrg.id } },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${userAdmin.id}`,
+        username: userEmail,
+        organization: {
+          connect: {
+            id: org.id,
+          },
+        },
+        user: {
+          connect: {
+            id: userAdmin.id,
+          },
+        },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "ADMIN",
+        user: { connect: { id: userAdmin.id } },
+        team: { connect: { id: org.id } },
+        accepted: true,
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: teammate1.id } },
+        team: { connect: { id: team.id } },
+        accepted: true,
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: teammate2.id } },
+        team: { connect: { id: team.id } },
+        accepted: true,
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: falseTestUser.id } },
+        team: { connect: { id: falseTestTeam.id } },
+        accepted: true,
+      });
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    it("should be defined", () => {
+      expect(userRepositoryFixture).toBeDefined();
+      expect(organizationsRepositoryFixture).toBeDefined();
+      expect(userAdmin).toBeDefined();
+      expect(org).toBeDefined();
+    });
+
+    it("should not be able to create event-type for team outside org", async () => {
+      const body: CreateTeamEventTypeInput_2024_06_14 = {
+        title: "Coding consultation",
+        slug: "coding-consultation",
+        description: "Our team will review your codebase.",
+        lengthInMinutes: 60,
+        locations: [
+          {
+            type: "integration",
+            integration: "cal-video",
+          },
+        ],
+        schedulingType: "COLLECTIVE",
+        hosts: [
+          {
+            userId: teammate1.id,
+            mandatory: true,
+            priority: "high",
+          },
+        ],
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/organizations/${org.id}/teams/${falseTestTeam.id}/event-types`)
+        .send(body)
+        .expect(404);
+    });
+
+    it("should not be able to create event-type for user outside org", async () => {
+      const userId = falseTestUser.id;
+
+      const body: CreateTeamEventTypeInput_2024_06_14 = {
+        title: "Coding consultation",
+        slug: "coding-consultation",
+        description: "Our team will review your codebase.",
+        lengthInMinutes: 60,
+        locations: [
+          {
+            type: "integration",
+            integration: "cal-video",
+          },
+        ],
+        schedulingType: "COLLECTIVE",
+        hosts: [
+          {
+            userId,
+            mandatory: true,
+            priority: "high",
+          },
+        ],
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/organizations/${org.id}/teams/${team.id}/event-types`)
+        .send(body)
+        .expect(404);
+    });
+
+    it("should create a collective team event-type", async () => {
+      const body: CreateTeamEventTypeInput_2024_06_14 = {
+        title: "Coding consultation collective",
+        slug: "coding-consultation collective",
+        description: "Our team will review your codebase.",
+        lengthInMinutes: 60,
+        locations: [
+          {
+            type: "integration",
+            integration: "cal-video",
+          },
+        ],
+        bookingFields: [
+          {
+            type: "select",
+            label: "select which language is your codebase in",
+            slug: "select-language",
+            required: true,
+            placeholder: "select language",
+            options: ["javascript", "python", "cobol"],
+          },
+        ],
+        schedulingType: "COLLECTIVE",
+        hosts: [
+          {
+            userId: teammate1.id,
+            mandatory: true,
+            priority: "high",
+          },
+          {
+            userId: teammate2.id,
+            mandatory: false,
+            priority: "low",
+          },
+        ],
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/organizations/${org.id}/teams/${team.id}/event-types`)
+        .send(body)
+        .expect(201)
+        .then((response) => {
+          const responseBody: ApiSuccessResponse<TeamEventTypeOutput_2024_06_14> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+
+          const data = responseBody.data;
+          expect(data.title).toEqual(body.title);
+          expect(data.hosts.length).toEqual(2);
+          evaluateHost(body.hosts[0], data.hosts[0]);
+          evaluateHost(body.hosts[1], data.hosts[1]);
+
+          collectiveEventType = responseBody.data;
+        });
+    });
+
+    it("should create a managed team event-type", async () => {
+      const body: CreateTeamEventTypeInput_2024_06_14 = {
+        title: "Coding consultation managed",
+        slug: "coding-consultation-managed",
+        description: "Our team will review your codebase.",
+        lengthInMinutes: 60,
+        locations: [
+          {
+            type: "integration",
+            integration: "cal-video",
+          },
+        ],
+        schedulingType: "MANAGED",
+        hosts: [
+          {
+            userId: teammate1.id,
+            mandatory: true,
+            priority: "high",
+          },
+          {
+            userId: teammate2.id,
+            mandatory: false,
+            priority: "low",
+          },
+        ],
+      };
+
+      return request(app.getHttpServer())
+        .post(`/v2/organizations/${org.id}/teams/${team.id}/event-types`)
+        .send(body)
+        .expect(201)
+        .then(async (response) => {
+          const responseBody: ApiSuccessResponse<TeamEventTypeOutput_2024_06_14[]> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+
+          const data = responseBody.data;
+          expect(data.length).toEqual(3);
+
+          const teammate1EventTypes = await eventTypesRepositoryFixture.getAllUserEventTypes(teammate1.id);
+          const teammate2EventTypes = await eventTypesRepositoryFixture.getAllUserEventTypes(teammate2.id);
+          const teamEventTypes = await eventTypesRepositoryFixture.getAllTeamEventTypes(team.id);
+
+          expect(teammate1EventTypes.length).toEqual(1);
+          expect(teammate2EventTypes.length).toEqual(1);
+          expect(teamEventTypes.filter((eventType) => eventType.schedulingType === "MANAGED").length).toEqual(
+            1
+          );
+
+          const responseTeamEvent = responseBody.data[0];
+          expect(responseTeamEvent?.teamId).toEqual(team.id);
+
+          const responseTeammate1Event = responseBody.data[1];
+          expect(responseTeammate1Event?.ownerId).toEqual(teammate1.id);
+          expect(responseTeammate1Event?.parentEventTypeId).toEqual(responseTeamEvent?.id);
+
+          const responseTeammate2Event = responseBody.data[2];
+          expect(responseTeammate2Event?.ownerId).toEqual(teammate2.id);
+          expect(responseTeammate2Event?.parentEventTypeId).toEqual(responseTeamEvent?.id);
+
+          managedEventType = responseTeamEvent;
+        });
+    });
+
+    it("should not get an event-type of team outside org", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${falseTestTeam.id}/event-types/${collectiveEventType.id}`)
+        .expect(404);
+    });
+
+    it("should not get a non existing event-type", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${team.id}/event-types/999999`)
+        .expect(404);
+    });
+
+    it("should get a team event-type", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${team.id}/event-types/${collectiveEventType.id}`)
+        .expect(200)
+        .then((response) => {
+          const responseBody: ApiSuccessResponse<TeamEventTypeOutput_2024_06_14> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+
+          const data = responseBody.data;
+          expect(data.title).toEqual(collectiveEventType.title);
+          expect(data.hosts.length).toEqual(2);
+          evaluateHost(collectiveEventType.hosts[0], data.hosts[0]);
+          evaluateHost(collectiveEventType.hosts[1], data.hosts[1]);
+
+          collectiveEventType = responseBody.data;
+        });
+    });
+
+    it("should not get event-types of team outside org", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${falseTestTeam.id}/event-types`)
+        .expect(404);
+    });
+
+    it("should get team event-types", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${team.id}/event-types`)
+        .expect(200)
+        .then((response) => {
+          const responseBody: ApiSuccessResponse<TeamEventTypeOutput_2024_06_14[]> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+
+          const data = responseBody.data;
+          console.log("asap responseBody.data", JSON.stringify(responseBody.data, null, 2));
+          expect(data.length).toEqual(2);
+
+          const eventTypeCollective = data.find((eventType) => eventType.schedulingType === "COLLECTIVE");
+          const eventTypeManaged = data.find((eventType) => eventType.schedulingType === "MANAGED");
+
+          expect(eventTypeCollective?.title).toEqual(collectiveEventType.title);
+          expect(eventTypeCollective?.hosts.length).toEqual(2);
+
+          expect(eventTypeManaged?.title).toEqual(managedEventType.title);
+          expect(eventTypeManaged?.hosts.length).toEqual(2);
+          evaluateHost(collectiveEventType.hosts[0], eventTypeCollective?.hosts[0]);
+          evaluateHost(collectiveEventType.hosts[1], eventTypeCollective?.hosts[1]);
+        });
+    });
+
+    it("should not be able to update event-type for incorrect team", async () => {
+      const body: UpdateTeamEventTypeInput_2024_06_14 = {
+        title: "Clean code consultation",
+      };
+
+      return request(app.getHttpServer())
+        .patch(`/v2/organizations/${org.id}/teams/${falseTestTeam.id}/event-types/${collectiveEventType.id}`)
+        .send(body)
+        .expect(404);
+    });
+
+    it("should not be able to update non existing event-type", async () => {
+      const body: UpdateTeamEventTypeInput_2024_06_14 = {
+        title: "Clean code consultation",
+      };
+
+      return request(app.getHttpServer())
+        .patch(`/v2/organizations/${org.id}/teams/${team.id}/event-types/999999`)
+        .send(body)
+        .expect(404);
+    });
+
+    it("should update collective event-type", async () => {
+      const newHosts: UpdateTeamEventTypeInput_2024_06_14["hosts"] = [
+        {
+          userId: teammate1.id,
+          mandatory: true,
+          priority: "medium",
+        },
+      ];
+
+      const body: UpdateTeamEventTypeInput_2024_06_14 = {
+        hosts: newHosts,
+      };
+
+      return request(app.getHttpServer())
+        .patch(`/v2/organizations/${org.id}/teams/${team.id}/event-types/${collectiveEventType.id}`)
+        .send(body)
+        .expect(200)
+        .then((response) => {
+          const responseBody: ApiSuccessResponse<TeamEventTypeOutput_2024_06_14> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+
+          const eventType = responseBody.data;
+          expect(eventType.title).toEqual(collectiveEventType.title);
+          expect(eventType.hosts.length).toEqual(1);
+          evaluateHost(eventType.hosts[0], newHosts[0]);
+        });
+    });
+
+    it("should update managed event-type", async () => {
+      const newTitle = "Coding consultation managed updated";
+      const newHosts: UpdateTeamEventTypeInput_2024_06_14["hosts"] = [
+        {
+          userId: teammate1.id,
+          mandatory: true,
+          priority: "medium",
+        },
+      ];
+
+      const body: UpdateTeamEventTypeInput_2024_06_14 = {
+        title: newTitle,
+        hosts: newHosts,
+      };
+
+      return request(app.getHttpServer())
+        .patch(`/v2/organizations/${org.id}/teams/${team.id}/event-types/${managedEventType.id}`)
+        .send(body)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: ApiSuccessResponse<TeamEventTypeOutput_2024_06_14[]> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+
+          const data = responseBody.data;
+          expect(data.length).toEqual(2);
+
+          const teammate1EventTypes = await eventTypesRepositoryFixture.getAllUserEventTypes(teammate1.id);
+          const teammate2EventTypes = await eventTypesRepositoryFixture.getAllUserEventTypes(teammate2.id);
+          const teamEventTypes = await eventTypesRepositoryFixture.getAllTeamEventTypes(team.id);
+          const managedTeamEventTypes = teamEventTypes.filter(
+            (eventType) => eventType.schedulingType === "MANAGED"
+          );
+
+          expect(teammate1EventTypes.length).toEqual(1);
+          expect(teammate2EventTypes.length).toEqual(0);
+          expect(managedTeamEventTypes.length).toEqual(1);
+          expect(managedTeamEventTypes[0].assignAllTeamMembers).toEqual(false);
+
+          const responseTeamEvent = responseBody.data[0];
+          expect(responseTeamEvent.title).toEqual(newTitle);
+          expect(responseTeamEvent.assignAllTeamMembers).toEqual(false);
+
+          const responseTeammate1Event = responseBody.data[1];
+          expect(responseTeammate1Event.title).toEqual(newTitle);
+
+          expect(teammate1EventTypes[0].title).toEqual(newTitle);
+          expect(
+            teamEventTypes.filter((eventType) => eventType.schedulingType === "MANAGED")?.[0]?.title
+          ).toEqual(newTitle);
+
+          managedEventType = responseBody.data[0];
+        });
+    });
+
+    it("should assign all members to managed event-type", async () => {
+      const body: UpdateTeamEventTypeInput_2024_06_14 = {
+        assignAllTeamMembers: true,
+      };
+
+      return request(app.getHttpServer())
+        .patch(`/v2/organizations/${org.id}/teams/${team.id}/event-types/${managedEventType.id}`)
+        .send(body)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: ApiSuccessResponse<TeamEventTypeOutput_2024_06_14[]> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+
+          const data = responseBody.data;
+          expect(data.length).toEqual(3);
+
+          const teammate1EventTypes = await eventTypesRepositoryFixture.getAllUserEventTypes(teammate1.id);
+          const teammate2EventTypes = await eventTypesRepositoryFixture.getAllUserEventTypes(teammate2.id);
+          const teamEventTypes = await eventTypesRepositoryFixture.getAllTeamEventTypes(team.id);
+          const managedTeamEventTypes = teamEventTypes.filter(
+            (eventType) => eventType.schedulingType === "MANAGED"
+          );
+
+          expect(teammate1EventTypes.length).toEqual(1);
+          expect(teammate2EventTypes.length).toEqual(1);
+          expect(managedTeamEventTypes.length).toEqual(1);
+          expect(managedTeamEventTypes[0].assignAllTeamMembers).toEqual(true);
+
+          const responseTeamEvent = responseBody.data[0];
+          expect(responseTeamEvent?.teamId).toEqual(team.id);
+          expect(responseTeamEvent.assignAllTeamMembers).toEqual(true);
+
+          const responseTeammate1Event = responseBody.data[1];
+          expect(responseTeammate1Event?.ownerId).toEqual(teammate1.id);
+          expect(responseTeammate1Event?.parentEventTypeId).toEqual(responseTeamEvent?.id);
+
+          const responseTeammate2Event = responseBody.data[2];
+          expect(responseTeammate2Event?.ownerId).toEqual(teammate2.id);
+          expect(responseTeammate2Event?.parentEventTypeId).toEqual(responseTeamEvent?.id);
+
+          managedEventType = responseTeamEvent;
+        });
+    });
+
+    it("should not delete event-type of team outside org", async () => {
+      return request(app.getHttpServer())
+        .delete(`/v2/organizations/${org.id}/teams/${falseTestTeam.id}/event-types/${collectiveEventType.id}`)
+        .expect(404);
+    });
+
+    it("should delete event-type not part of the team", async () => {
+      return request(app.getHttpServer())
+        .delete(`/v2/organizations/${org.id}/teams/${team.id}/event-types/99999`)
+        .expect(404);
+    });
+
+    it("should delete collective event-type", async () => {
+      return request(app.getHttpServer())
+        .delete(`/v2/organizations/${org.id}/teams/${team.id}/event-types/${collectiveEventType.id}`)
+        .expect(200);
+    });
+
+    it("should delete managed event-type", async () => {
+      return request(app.getHttpServer())
+        .delete(`/v2/organizations/${org.id}/teams/${team.id}/event-types/${managedEventType.id}`)
+        .expect(200);
+    });
+
+    function evaluateHost(expected: Host, received: Host | undefined) {
+      expect(expected.userId).toEqual(received?.userId);
+      expect(expected.mandatory).toEqual(received?.mandatory);
+      expect(expected.priority).toEqual(received?.priority);
+    }
+
+    afterAll(async () => {
+      await userRepositoryFixture.deleteByEmail(userAdmin.email);
+      await userRepositoryFixture.deleteByEmail(teammate1.email);
+      await userRepositoryFixture.deleteByEmail(teammate2.email);
+      await teamsRepositoryFixture.delete(team.id);
+      await organizationsRepositoryFixture.delete(org.id);
+      await app.close();
+    });
+  });
+});

apps/api/v2/src/modules/organizations/controllers/event-types/outputs/teams/create-team-event-type.output.ts

@@ -0,0 +1,21 @@
+import { ApiProperty, getSchemaPath } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsNotEmptyObject, ValidateNested } from "class-validator";
+
+import { ApiResponseWithoutData, TeamEventTypeOutput_2024_06_14 } from "@calcom/platform-types";
+
+export class CreateTeamEventTypeOutput extends ApiResponseWithoutData {
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @ApiProperty({
+    oneOf: [
+      { $ref: getSchemaPath(TeamEventTypeOutput_2024_06_14) },
+      {
+        type: "array",
+        items: { $ref: getSchemaPath(TeamEventTypeOutput_2024_06_14) },
+      },
+    ],
+  })
+  @Type(() => TeamEventTypeOutput_2024_06_14)
+  data!: TeamEventTypeOutput_2024_06_14 | TeamEventTypeOutput_2024_06_14[];
+}

apps/api/v2/src/modules/organizations/controllers/event-types/outputs/teams/delete-team-event-type.output.ts

@@ -0,0 +1,10 @@
+import { Type } from "class-transformer";
+import { ValidateNested } from "class-validator";
+
+import { ApiResponseWithoutData, TeamEventTypeOutput_2024_06_14 } from "@calcom/platform-types";
+
+export class DeleteTeamEventTypeOutput extends ApiResponseWithoutData {
+  @ValidateNested()
+  @Type(() => TeamEventTypeOutput_2024_06_14)
+  data!: Pick<TeamEventTypeOutput_2024_06_14, "id" | "title">;
+}

apps/api/v2/src/modules/organizations/controllers/event-types/outputs/teams/get-team-event-type.output.ts

@@ -0,0 +1,10 @@
+import { Type } from "class-transformer";
+import { ValidateNested } from "class-validator";
+
+import { ApiResponseWithoutData, TeamEventTypeOutput_2024_06_14 } from "@calcom/platform-types";
+
+export class GetTeamEventTypeOutput extends ApiResponseWithoutData {
+  @ValidateNested()
+  @Type(() => TeamEventTypeOutput_2024_06_14)
+  data!: TeamEventTypeOutput_2024_06_14;
+}

apps/api/v2/src/modules/organizations/controllers/event-types/outputs/teams/get-team-event-types.output.ts

@@ -0,0 +1,10 @@
+import { Type } from "class-transformer";
+import { ValidateNested } from "class-validator";
+
+import { ApiResponseWithoutData, TeamEventTypeOutput_2024_06_14 } from "@calcom/platform-types";
+
+export class GetTeamEventTypesOutput extends ApiResponseWithoutData {
+  @ValidateNested({ each: true })
+  @Type(() => TeamEventTypeOutput_2024_06_14)
+  data!: TeamEventTypeOutput_2024_06_14[];
+}

apps/api/v2/src/modules/organizations/controllers/event-types/outputs/teams/update-team-event-type.output.ts

@@ -0,0 +1,21 @@
+import { ApiProperty, getSchemaPath } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsNotEmptyObject, ValidateNested } from "class-validator";
+
+import { ApiResponseWithoutData, TeamEventTypeOutput_2024_06_14 } from "@calcom/platform-types";
+
+export class UpdateTeamEventTypeOutput extends ApiResponseWithoutData {
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @ApiProperty({
+    oneOf: [
+      { $ref: getSchemaPath(TeamEventTypeOutput_2024_06_14) },
+      {
+        type: "array",
+        items: { $ref: getSchemaPath(TeamEventTypeOutput_2024_06_14) },
+      },
+    ],
+  })
+  @Type(() => TeamEventTypeOutput_2024_06_14)
+  data!: TeamEventTypeOutput_2024_06_14 | TeamEventTypeOutput_2024_06_14[];
+}

apps/api/v2/src/modules/organizations/organizations.module.ts

@@ -1,18 +1,24 @@
+import { EventTypesModule_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.module";
 import { SchedulesModule_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.module";
 import { EmailModule } from "@/modules/email/email.module";
 import { EmailService } from "@/modules/email/email.service";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
+import { OrganizationsEventTypesController } from "@/modules/organizations/controllers/event-types/organizations-event-types.controller";
 import { OrganizationsMembershipsController } from "@/modules/organizations/controllers/memberships/organizations-membership.controller";
 import { OrganizationsSchedulesController } from "@/modules/organizations/controllers/schedules/organizations-schedules.controller";
 import { OrganizationsTeamsMembershipsController } from "@/modules/organizations/controllers/teams/memberships/organizations-teams-memberships.controller";
 import { OrganizationsTeamsController } from "@/modules/organizations/controllers/teams/organizations-teams.controller";
 import { OrganizationsUsersController } from "@/modules/organizations/controllers/users/organizations-users.controller";
 import { OrganizationsRepository } from "@/modules/organizations/organizations.repository";
+import { OrganizationsEventTypesRepository } from "@/modules/organizations/repositories/organizations-event-types.repository";
 import { OrganizationsMembershipRepository } from "@/modules/organizations/repositories/organizations-membership.repository";
 import { OrganizationSchedulesRepository } from "@/modules/organizations/repositories/organizations-schedules.repository";
 import { OrganizationsTeamsMembershipsRepository } from "@/modules/organizations/repositories/organizations-teams-memberships.repository";
 import { OrganizationsTeamsRepository } from "@/modules/organizations/repositories/organizations-teams.repository";
 import { OrganizationsUsersRepository } from "@/modules/organizations/repositories/organizations-users.repository";
+import { InputOrganizationsEventTypesService } from "@/modules/organizations/services/event-types/input.service";
+import { OrganizationsEventTypesService } from "@/modules/organizations/services/event-types/organizations-event-types.service";
+import { OutputOrganizationsEventTypesService } from "@/modules/organizations/services/event-types/output.service";
 import { OrganizationsMembershipService } from "@/modules/organizations/services/organizations-membership.service";
 import { OrganizationsSchedulesService } from "@/modules/organizations/services/organizations-schedules.service";
 import { OrganizationsTeamsMembershipsService } from "@/modules/organizations/services/organizations-teams-memberships.service";
@@ -26,7 +32,15 @@ import { UsersModule } from "@/modules/users/users.module";
 import { Module } from "@nestjs/common";
 
 @Module({
-  imports: [PrismaModule, StripeModule, SchedulesModule_2024_06_11, UsersModule, RedisModule, EmailModule],
+  imports: [
+    PrismaModule,
+    StripeModule,
+    SchedulesModule_2024_06_11,
+    UsersModule,
+    RedisModule,
+    EmailModule,
+    EventTypesModule_2024_06_14,
+  ],
   providers: [
     OrganizationsRepository,
     OrganizationsTeamsRepository,
@@ -40,6 +54,10 @@ import { Module } from "@nestjs/common";
     EmailService,
     OrganizationsMembershipRepository,
     OrganizationsMembershipService,
+    OrganizationsEventTypesService,
+    InputOrganizationsEventTypesService,
+    OutputOrganizationsEventTypesService,
+    OrganizationsEventTypesRepository,
     OrganizationsTeamsMembershipsRepository,
     OrganizationsTeamsMembershipsService,
   ],
@@ -59,6 +77,7 @@ import { Module } from "@nestjs/common";
     OrganizationsSchedulesController,
     OrganizationsUsersController,
     OrganizationsMembershipsController,
+    OrganizationsEventTypesController,
     OrganizationsTeamsMembershipsController,
   ],
 })

apps/api/v2/src/modules/organizations/repositories/organizations-event-types.repository.ts

@@ -0,0 +1,61 @@
+import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class OrganizationsEventTypesRepository {
+  constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
+
+  async getTeamEventType(teamId: number, eventTypeId: number) {
+    return this.dbRead.prisma.eventType.findUnique({
+      where: {
+        id: eventTypeId,
+        teamId,
+      },
+      include: { users: true, schedule: true, hosts: true },
+    });
+  }
+
+  async getTeamEventTypes(teamId: number) {
+    return this.dbRead.prisma.eventType.findMany({
+      where: {
+        teamId,
+      },
+      include: { users: true, schedule: true, hosts: true },
+    });
+  }
+
+  async getEventTypeById(eventTypeId: number) {
+    return this.dbRead.prisma.eventType.findUnique({
+      where: { id: eventTypeId },
+      include: { users: true, schedule: true, hosts: true },
+    });
+  }
+
+  async getEventTypeChildren(eventTypeId: number) {
+    return this.dbRead.prisma.eventType.findMany({
+      where: { parentId: eventTypeId },
+      include: { users: true, schedule: true, hosts: true },
+    });
+  }
+
+  async getTeamsEventTypes(orgId: number, skip: number, take: number) {
+    return this.dbRead.prisma.eventType.findMany({
+      where: {
+        team: {
+          parentId: orgId,
+        },
+      },
+      skip,
+      take,
+      include: { users: true, schedule: true, hosts: true },
+    });
+  }
+
+  async getEventTypeByIdWithChildren(eventTypeId: number) {
+    return this.dbRead.prisma.eventType.findUnique({
+      where: { id: eventTypeId },
+      include: { children: true },
+    });
+  }
+}

apps/api/v2/src/modules/organizations/repositories/organizations-teams.repository.ts

@@ -1,17 +1,10 @@
-import { PlatformPlan } from "@/modules/billing/types";
 import { CreateOrgTeamDto } from "@/modules/organizations/inputs/create-organization-team.input";
 import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
-import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
-import { StripeService } from "@/modules/stripe/stripe.service";
 import { Injectable } from "@nestjs/common";
 
 @Injectable()
 export class OrganizationsTeamsRepository {
-  constructor(
-    private readonly dbRead: PrismaReadService,
-    private readonly dbWrite: PrismaWriteService,
-    private readonly stripeService: StripeService
-  ) {}
+  constructor(private readonly dbRead: PrismaReadService) {}
 
   async findOrgTeam(organizationId: number, teamId: number) {
     return this.dbRead.prisma.team.findUnique({
@@ -55,4 +48,20 @@ export class OrganizationsTeamsRepository {
       take,
     });
   }
+
+  async getTeamMembersIds(teamId: number) {
+    const team = await this.dbRead.prisma.team.findUnique({
+      where: {
+        id: teamId,
+      },
+      include: {
+        members: true,
+      },
+    });
+    if (!team) {
+      return [];
+    }
+
+    return team.members.map((member) => member.userId);
+  }
 }

apps/api/v2/src/modules/organizations/services/event-types/input.service.ts

@@ -0,0 +1,162 @@
+import { InputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/input-event-types.service";
+import { OrganizationsEventTypesRepository } from "@/modules/organizations/repositories/organizations-event-types.repository";
+import { OrganizationsTeamsRepository } from "@/modules/organizations/repositories/organizations-teams.repository";
+import { UsersRepository } from "@/modules/users/users.repository";
+import { Injectable } from "@nestjs/common";
+
+import {
+  CreateTeamEventTypeInput_2024_06_14,
+  UpdateTeamEventTypeInput_2024_06_14,
+  HostPriority,
+} from "@calcom/platform-types";
+
+@Injectable()
+export class InputOrganizationsEventTypesService {
+  constructor(
+    private readonly inputEventTypesService: InputEventTypesService_2024_06_14,
+    private readonly organizationsTeamsRepository: OrganizationsTeamsRepository,
+    private readonly usersRepository: UsersRepository,
+    private readonly orgEventTypesRepository: OrganizationsEventTypesRepository
+  ) {}
+  async transformInputCreateTeamEventType(
+    teamId: number,
+    inputEventType: CreateTeamEventTypeInput_2024_06_14
+  ) {
+    const { hosts, assignAllTeamMembers, ...rest } = inputEventType;
+
+    const eventType = this.inputEventTypesService.transformInputCreateEventType(rest);
+
+    const metadata = rest.schedulingType === "MANAGED" ? { managedEventConfig: {} } : undefined;
+
+    const teamEventType = {
+      ...eventType,
+      hosts: assignAllTeamMembers ? await this.getAllTeamMembers(teamId) : this.transformInputHosts(hosts),
+      assignAllTeamMembers,
+      metadata,
+    };
+
+    return teamEventType;
+  }
+
+  async transformInputUpdateTeamEventType(
+    eventTypeId: number,
+    teamId: number,
+    inputEventType: UpdateTeamEventTypeInput_2024_06_14
+  ) {
+    const { hosts, assignAllTeamMembers, ...rest } = inputEventType;
+
+    const eventType = this.inputEventTypesService.transformInputUpdateEventType(rest);
+
+    const children = await this.getChildEventTypesForManagedEventType(eventTypeId, inputEventType, teamId);
+    const teamEventType = {
+      ...eventType,
+      // note(Lauris): we don't populate hosts for managed event-types because they are handled by the children
+      hosts: !children
+        ? assignAllTeamMembers
+          ? await this.getAllTeamMembers(teamId)
+          : this.transformInputHosts(hosts)
+        : undefined,
+      assignAllTeamMembers,
+      children,
+    };
+
+    return teamEventType;
+  }
+
+  async getChildEventTypesForManagedEventType(
+    eventTypeId: number,
+    inputEventType: UpdateTeamEventTypeInput_2024_06_14,
+    teamId: number
+  ) {
+    const eventType = await this.orgEventTypesRepository.getEventTypeByIdWithChildren(eventTypeId);
+
+    if (!eventType || eventType.schedulingType !== "MANAGED") {
+      return undefined;
+    }
+
+    const ownersIds = await this.getOwnersIdsForManagedEventType(teamId, inputEventType, eventType);
+    const owners = await this.getOwnersForManagedEventType(ownersIds);
+
+    return owners.map((owner) => {
+      return {
+        hidden: false,
+        owner,
+      };
+    });
+  }
+
+  async getOwnersIdsForManagedEventType(
+    teamId: number,
+    inputEventType: UpdateTeamEventTypeInput_2024_06_14,
+    eventType: { children: { userId: number | null }[] }
+  ) {
+    if (inputEventType.assignAllTeamMembers) {
+      return await this.organizationsTeamsRepository.getTeamMembersIds(teamId);
+    }
+
+    // note(Lauris): when API user updates managed event type users
+    if (inputEventType.hosts) {
+      return inputEventType.hosts.map((host) => host.userId);
+    }
+
+    // note(Lauris): when API user DOES NOT update managed event type users, but we still need existing managed event type users to know which event-types to update
+    return eventType.children.map((child) => child.userId).filter((id) => !!id) as number[];
+  }
+
+  async getOwnersForManagedEventType(userIds: number[]) {
+    const users = await this.usersRepository.findByIdsWithEventTypes(userIds);
+
+    return users.map((user) => {
+      const nonManagedEventTypes = user.eventTypes.filter((eventType) => !eventType.parentId);
+      return {
+        id: user.id,
+        name: user.name || user.email,
+        email: user.email,
+        // note(Lauris): managed event types slugs have to be excluded otherwise checkExistentEventTypes within handleChildrenEventTypes.ts will incorrectly delete managed user event type.
+        eventTypeSlugs: nonManagedEventTypes.map((eventType) => eventType.slug),
+      };
+    });
+  }
+
+  async getAllTeamMembers(teamId: number) {
+    const membersIds = await this.organizationsTeamsRepository.getTeamMembersIds(teamId);
+
+    return membersIds.map((id) => ({
+      userId: id,
+      isFixed: false,
+      priority: 2,
+    }));
+  }
+
+  transformInputHosts(inputHosts: CreateTeamEventTypeInput_2024_06_14["hosts"] | undefined) {
+    if (!inputHosts) {
+      return undefined;
+    }
+
+    const defaultMandatory = false;
+    const defaultPriority = "medium";
+
+    return inputHosts.map((host) => ({
+      userId: host.userId,
+      isFixed: host.mandatory || defaultMandatory,
+      priority: getPriorityValue(host.priority || defaultPriority),
+    }));
+  }
+}
+
+function getPriorityValue(priority: keyof typeof HostPriority): number {
+  switch (priority) {
+    case "lowest":
+      return 0;
+    case "low":
+      return 1;
+    case "medium":
+      return 2;
+    case "high":
+      return 3;
+    case "highest":
+      return 4;
+    default:
+      throw new Error("Invalid HostPriority label");
+  }
+}

apps/api/v2/src/modules/organizations/services/event-types/organizations-event-types.service.ts

@@ -0,0 +1,179 @@
+import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
+import { EventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/event-types.service";
+import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
+import { OrganizationsEventTypesRepository } from "@/modules/organizations/repositories/organizations-event-types.repository";
+import { OrganizationsTeamsRepository } from "@/modules/organizations/repositories/organizations-teams.repository";
+import { InputOrganizationsEventTypesService } from "@/modules/organizations/services/event-types/input.service";
+import { OutputOrganizationsEventTypesService } from "@/modules/organizations/services/event-types/output.service";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { UserWithProfile } from "@/modules/users/users.repository";
+import { Injectable, NotFoundException } from "@nestjs/common";
+
+import { createEventType, updateEventType } from "@calcom/platform-libraries-0.0.19";
+import {
+  CreateTeamEventTypeInput_2024_06_14,
+  UpdateTeamEventTypeInput_2024_06_14,
+} from "@calcom/platform-types";
+
+@Injectable()
+export class OrganizationsEventTypesService {
+  constructor(
+    private readonly inputService: InputOrganizationsEventTypesService,
+    private readonly eventTypesService: EventTypesService_2024_06_14,
+    private readonly dbWrite: PrismaWriteService,
+    private readonly organizationEventTypesRepository: OrganizationsEventTypesRepository,
+    private readonly eventTypesRepository: EventTypesRepository_2024_06_14,
+    private readonly outputService: OutputOrganizationsEventTypesService,
+    private readonly membershipsRepository: MembershipsRepository,
+    private readonly organizationsTeamsRepository: OrganizationsTeamsRepository
+  ) {}
+
+  async createTeamEventType(
+    user: UserWithProfile,
+    teamId: number,
+    orgId: number,
+    body: CreateTeamEventTypeInput_2024_06_14
+  ) {
+    await this.validateHosts(teamId, body.hosts);
+    const eventTypeUser = await this.getUserToCreateTeamEvent(user, orgId);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { hosts, assignAllTeamMembers, ...rest } =
+      await this.inputService.transformInputCreateTeamEventType(teamId, body);
+    const { eventType: eventTypeCreated } = await createEventType({
+      input: { teamId: teamId, ...rest },
+      ctx: {
+        user: eventTypeUser,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        prisma: this.dbWrite.prisma,
+      },
+    });
+
+    return await this.updateTeamEventType(
+      eventTypeCreated.id,
+      teamId,
+      { hosts: body.hosts, assignAllTeamMembers },
+      user
+    );
+  }
+
+  async validateHosts(teamId: number, hosts: CreateTeamEventTypeInput_2024_06_14["hosts"] | undefined) {
+    if (hosts && hosts.length) {
+      const membersIds = await this.organizationsTeamsRepository.getTeamMembersIds(teamId);
+      const invalidHosts = hosts.filter((host) => !membersIds.includes(host.userId));
+      if (invalidHosts.length) {
+        throw new NotFoundException(`Invalid hosts: ${invalidHosts.join(", ")}`);
+      }
+    }
+  }
+
+  async validateEventTypeExists(teamId: number, eventTypeId: number) {
+    const eventType = await this.organizationEventTypesRepository.getTeamEventType(teamId, eventTypeId);
+
+    if (!eventType) {
+      throw new NotFoundException(`Event type with id ${eventTypeId} not found`);
+    }
+  }
+
+  async getUserToCreateTeamEvent(user: UserWithProfile, organizationId: number) {
+    const isOrgAdmin = await this.membershipsRepository.isUserOrganizationAdmin(user.id, organizationId);
+    const profileId = user.movedToProfileId || null;
+    return {
+      id: user.id,
+      role: user.role,
+      organizationId: user.organizationId,
+      organization: { isOrgAdmin },
+      profile: { id: profileId },
+      metadata: user.metadata,
+    };
+  }
+
+  async getTeamEventType(teamId: number, eventTypeId: number) {
+    const eventType = await this.organizationEventTypesRepository.getTeamEventType(teamId, eventTypeId);
+
+    if (!eventType) {
+      return null;
+    }
+
+    return this.outputService.getResponseTeamEventType(eventType);
+  }
+
+  async getTeamEventTypes(teamId: number) {
+    const eventTypes = await this.organizationEventTypesRepository.getTeamEventTypes(teamId);
+
+    const eventTypePromises = eventTypes.map(async (eventType) => {
+      return await this.outputService.getResponseTeamEventType(eventType);
+    });
+
+    return await Promise.all(eventTypePromises);
+  }
+
+  async getTeamsEventTypes(orgId: number, skip = 0, take = 250) {
+    const eventTypes = await this.organizationEventTypesRepository.getTeamsEventTypes(orgId, skip, take);
+
+    const eventTypePromises = eventTypes.map(async (eventType) => {
+      return await this.outputService.getResponseTeamEventType(eventType);
+    });
+
+    return await Promise.all(eventTypePromises);
+  }
+
+  async updateTeamEventType(
+    eventTypeId: number,
+    teamId: number,
+    body: UpdateTeamEventTypeInput_2024_06_14,
+    user: UserWithProfile
+  ) {
+    await this.validateEventTypeExists(teamId, eventTypeId);
+    await this.validateHosts(teamId, body.hosts);
+    const eventTypeUser = await this.eventTypesService.getUserToUpdateEvent(user);
+    const bodyTransformed = await this.inputService.transformInputUpdateTeamEventType(
+      eventTypeId,
+      teamId,
+      body
+    );
+
+    await updateEventType({
+      input: { id: eventTypeId, ...bodyTransformed },
+      ctx: {
+        user: eventTypeUser,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        prisma: this.dbWrite.prisma,
+      },
+    });
+
+    const eventType = await this.organizationEventTypesRepository.getEventTypeById(eventTypeId);
+
+    if (!eventType) {
+      throw new NotFoundException(`Event type with id ${eventTypeId} not found`);
+    }
+
+    if (eventType.schedulingType !== "MANAGED") {
+      return this.outputService.getResponseTeamEventType(eventType);
+    }
+
+    const children = await this.organizationEventTypesRepository.getEventTypeChildren(eventType.id);
+
+    const eventTypes = [eventType, ...children];
+
+    const eventTypePromises = eventTypes.map(async (e) => {
+      return await this.outputService.getResponseTeamEventType(e);
+    });
+
+    return await Promise.all(eventTypePromises);
+  }
+
+  async deleteTeamEventType(teamId: number, eventTypeId: number) {
+    const existingEventType = await this.organizationEventTypesRepository.getTeamEventType(
+      teamId,
+      eventTypeId
+    );
+
+    if (!existingEventType) {
+      throw new NotFoundException(`Event type with ID=${eventTypeId} does not exist.`);
+    }
+
+    return this.eventTypesRepository.deleteEventType(eventTypeId);
+  }
+}

apps/api/v2/src/modules/organizations/services/event-types/output.service.ts

@@ -0,0 +1,114 @@
+import { OutputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/output-event-types.service";
+import { OrganizationsEventTypesRepository } from "@/modules/organizations/repositories/organizations-event-types.repository";
+import { Injectable } from "@nestjs/common";
+import type { EventType, User, Schedule, Host } from "@prisma/client";
+
+import { HostPriority } from "@calcom/platform-types";
+
+type EventTypeRelations = { users: User[]; schedule: Schedule | null; hosts: Host[] };
+type DatabaseEventType = EventType & EventTypeRelations;
+
+type Input = Pick<
+  DatabaseEventType,
+  | "id"
+  | "length"
+  | "title"
+  | "description"
+  | "disableGuests"
+  | "slotInterval"
+  | "minimumBookingNotice"
+  | "beforeEventBuffer"
+  | "afterEventBuffer"
+  | "slug"
+  | "schedulingType"
+  | "requiresConfirmation"
+  | "price"
+  | "currency"
+  | "lockTimeZoneToggleOnBookingPage"
+  | "seatsPerTimeSlot"
+  | "forwardParamsSuccessRedirect"
+  | "successRedirectUrl"
+  | "seatsShowAvailabilityCount"
+  | "isInstantEvent"
+  | "locations"
+  | "bookingFields"
+  | "recurringEvent"
+  | "metadata"
+  | "users"
+  | "schedule"
+  | "hosts"
+  | "teamId"
+  | "userId"
+  | "parentId"
+  | "assignAllTeamMembers"
+>;
+
+@Injectable()
+export class OutputOrganizationsEventTypesService {
+  constructor(
+    private readonly outputEventTypesService: OutputEventTypesService_2024_06_14,
+    private readonly organizationEventTypesRepository: OrganizationsEventTypesRepository
+  ) {}
+
+  async getResponseTeamEventType(databaseEventType: Input) {
+    const { teamId, userId, parentId, assignAllTeamMembers } = databaseEventType;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { ownerId, users, ...rest } = await this.outputEventTypesService.getResponseEventType(
+      0,
+      databaseEventType
+    );
+    const hosts =
+      databaseEventType.schedulingType === "MANAGED"
+        ? await this.getManagedEventTypeHosts(databaseEventType.id)
+        : this.transformHosts(databaseEventType.hosts);
+
+    return {
+      ...rest,
+      hosts,
+      teamId,
+      ownerId: userId,
+      parentEventTypeId: parentId,
+      assignAllTeamMembers: teamId ? assignAllTeamMembers : undefined,
+    };
+  }
+
+  async getManagedEventTypeHosts(eventTypeId: number) {
+    const children = await this.organizationEventTypesRepository.getEventTypeChildren(eventTypeId);
+    const hostsIds: number[] = [];
+    for (const child of children) {
+      if (child.userId) {
+        hostsIds.push(child.userId);
+      }
+    }
+    return hostsIds.map((userId) => ({ userId }));
+  }
+
+  transformHosts(hosts: Host[]) {
+    if (!hosts) return [];
+
+    return hosts.map((host) => {
+      return {
+        userId: host.userId,
+        mandatory: host.isFixed,
+        priority: getPriorityLabel(host.priority || 2),
+      };
+    });
+  }
+}
+
+function getPriorityLabel(priority: number): keyof typeof HostPriority {
+  switch (priority) {
+    case 0:
+      return "lowest";
+    case 1:
+      return "low";
+    case 2:
+      return "medium";
+    case 3:
+      return "high";
+    case 4:
+      return "highest";
+    default:
+      throw new Error("Invalid HostPriority value");
+  }
+}

apps/api/v2/src/modules/organizations/services/organizations-users-service.ts

@@ -6,7 +6,7 @@ import { CreateUserInput } from "@/modules/users/inputs/create-user.input";
 import { Injectable, ConflictException } from "@nestjs/common";
 import { plainToInstance } from "class-transformer";
 
-import { createNewUsersConnectToOrgIfExists } from "@calcom/platform-libraries-0.0.18";
+import { createNewUsersConnectToOrgIfExists } from "@calcom/platform-libraries-0.0.19";
 import { Team } from "@calcom/prisma/client";
 
 @Injectable()

apps/api/v2/src/modules/slots/controllers/slots.controller.ts

@@ -5,8 +5,8 @@ import { ApiTags as DocsTags } from "@nestjs/swagger";
 import { Response as ExpressResponse, Request as ExpressRequest } from "express";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
-import { getAvailableSlots } from "@calcom/platform-libraries-0.0.18";
-import type { AvailableSlotsType } from "@calcom/platform-libraries-0.0.18";
+import { getAvailableSlots } from "@calcom/platform-libraries-0.0.19";
+import type { AvailableSlotsType } from "@calcom/platform-libraries-0.0.19";
 import { RemoveSelectedSlotInput, ReserveSlotInput } from "@calcom/platform-types";
 import { ApiResponse, GetAvailableSlotsInput } from "@calcom/platform-types";
 

apps/api/v2/src/modules/slots/slots.repository.ts

@@ -3,7 +3,7 @@ import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { Injectable } from "@nestjs/common";
 import { DateTime } from "luxon";
 
-import { MINUTES_TO_BOOK } from "@calcom/platform-libraries-0.0.18";
+import { MINUTES_TO_BOOK } from "@calcom/platform-libraries-0.0.19";
 import { ReserveSlotInput } from "@calcom/platform-types";
 
 @Injectable()

apps/api/v2/src/modules/timezones/controllers/timezones.controller.ts

@@ -4,7 +4,7 @@ import { Controller, Get } from "@nestjs/common";
 import { ApiTags as DocsTags } from "@nestjs/swagger";
 
 import { SUCCESS_STATUS } from "@calcom/platform-constants";
-import type { CityTimezones } from "@calcom/platform-libraries-0.0.18";
+import type { CityTimezones } from "@calcom/platform-libraries-0.0.19";
 import { ApiResponse } from "@calcom/platform-types";
 
 @Controller({

apps/api/v2/src/modules/timezones/services/timezones.service.ts

@@ -1,8 +1,8 @@
 import { RedisService } from "@/modules/redis/redis.service";
 import { Injectable } from "@nestjs/common";
 
-import { cityTimezonesHandler } from "@calcom/platform-libraries-0.0.18";
-import type { CityTimezones } from "@calcom/platform-libraries-0.0.18";
+import { cityTimezonesHandler } from "@calcom/platform-libraries-0.0.19";
+import type { CityTimezones } from "@calcom/platform-libraries-0.0.19";
 
 @Injectable()
 export class TimezonesService {

apps/api/v2/src/modules/users/users.repository.ts

@@ -77,6 +77,19 @@ export class UsersRepository {
     });
   }
 
+  async findByIdsWithEventTypes(userIds: number[]) {
+    return this.dbRead.prisma.user.findMany({
+      where: {
+        id: {
+          in: userIds,
+        },
+      },
+      include: {
+        eventTypes: true,
+      },
+    });
+  }
+
   async findByIdWithCalendars(userId: number) {
     return this.dbRead.prisma.user.findUnique({
       where: {

apps/api/v2/swagger/documentation.json

@@ -1085,6 +1085,16 @@
             }
           }
         ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateScheduleInput_2024_06_11"
+              }
+            }
+          }
+        },
         "responses": {
           "201": {
             "description": "",
@@ -1187,6 +1197,16 @@
             }
           }
         ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdateScheduleInput_2024_06_11"
+              }
+            }
+          }
+        },
         "responses": {
           "200": {
             "description": "",
@@ -1615,6 +1635,252 @@
         ]
       }
     },
+    "/v2/organizations/{orgId}/teams/{teamId}/event-types": {
+      "post": {
+        "operationId": "OrganizationsEventTypesController_createTeamEventType",
+        "parameters": [
+          {
+            "name": "teamId",
+            "required": true,
+            "in": "path",
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "orgId",
+            "required": true,
+            "in": "path",
+            "schema": {
+              "type": "number"
+            }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateTeamEventTypeInput_2024_06_14"
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/CreateTeamEventTypeOutput"
+                }
+              }
+            }
+          }
+        },
+        "tags": [
+          "Organizations Event Types"
+        ]
+      },
+      "get": {
+        "operationId": "OrganizationsEventTypesController_getTeamEventTypes",
+        "parameters": [
+          {
+            "name": "teamId",
+            "required": true,
+            "in": "path",
+            "schema": {
+              "type": "number"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/GetTeamEventTypesOutput"
+                }
+              }
+            }
+          }
+        },
+        "tags": [
+          "Organizations Event Types"
+        ]
+      }
+    },
+    "/v2/organizations/{orgId}/teams/{teamId}/event-types/{eventTypeId}": {
+      "get": {
+        "operationId": "OrganizationsEventTypesController_getTeamEventType",
+        "parameters": [
+          {
+            "name": "teamId",
+            "required": true,
+            "in": "path",
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "eventTypeId",
+            "required": true,
+            "in": "path",
+            "schema": {
+              "type": "number"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/GetTeamEventTypeOutput"
+                }
+              }
+            }
+          }
+        },
+        "tags": [
+          "Organizations Event Types"
+        ]
+      },
+      "patch": {
+        "operationId": "OrganizationsEventTypesController_updateTeamEventType",
+        "parameters": [
+          {
+            "name": "teamId",
+            "required": true,
+            "in": "path",
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "eventTypeId",
+            "required": true,
+            "in": "path",
+            "schema": {
+              "type": "number"
+            }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdateTeamEventTypeInput_2024_06_14"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UpdateTeamEventTypeOutput"
+                }
+              }
+            }
+          }
+        },
+        "tags": [
+          "Organizations Event Types"
+        ]
+      },
+      "delete": {
+        "operationId": "OrganizationsEventTypesController_deleteTeamEventType",
+        "parameters": [
+          {
+            "name": "teamId",
+            "required": true,
+            "in": "path",
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "eventTypeId",
+            "required": true,
+            "in": "path",
+            "schema": {
+              "type": "number"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DeleteTeamEventTypeOutput"
+                }
+              }
+            }
+          }
+        },
+        "tags": [
+          "Organizations Event Types"
+        ]
+      }
+    },
+    "/v2/organizations/{orgId}/teams/event-types": {
+      "get": {
+        "operationId": "OrganizationsEventTypesController_getTeamsEventTypes",
+        "parameters": [
+          {
+            "name": "orgId",
+            "required": true,
+            "in": "path",
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "take",
+            "required": false,
+            "in": "query",
+            "description": "The number of items to return",
+            "example": 10,
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "skip",
+            "required": false,
+            "in": "query",
+            "description": "The number of items to skip",
+            "example": 0,
+            "schema": {
+              "type": "number"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/GetTeamEventTypesOutput"
+                }
+              }
+            }
+          }
+        },
+        "tags": [
+          "Organizations Event Types"
+        ]
+      }
+    },
     "/v2/organizations/{orgId}/teams/{teamId}/memberships": {
       "get": {
         "operationId": "OrganizationsTeamsMembershipsController_getAllOrgTeamMemberships",
@@ -1980,6 +2246,16 @@
             }
           }
         ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdateScheduleInput_2024_04_15"
+              }
+            }
+          }
+        },
         "responses": {
           "200": {
             "description": "",
@@ -4905,6 +5181,57 @@
           "data"
         ]
       },
+      "CreateScheduleInput_2024_06_11": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "example": "One-on-one coaching"
+          },
+          "timeZone": {
+            "type": "string",
+            "example": "Europe/Rome"
+          },
+          "availability": {
+            "example": [
+              {
+                "days": [
+                  "Monday",
+                  "Tuesday"
+                ],
+                "startTime": "09:00",
+                "endTime": "10:00"
+              }
+            ],
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/ScheduleAvailabilityInput_2024_06_11"
+            }
+          },
+          "isDefault": {
+            "type": "boolean",
+            "example": true
+          },
+          "overrides": {
+            "example": [
+              {
+                "date": "2024-05-20",
+                "startTime": "12:00",
+                "endTime": "14:00"
+              }
+            ],
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/ScheduleOverrideInput_2024_06_11"
+            }
+          }
+        },
+        "required": [
+          "name",
+          "timeZone",
+          "isDefault"
+        ]
+      },
       "CreateScheduleOutput_2024_06_11": {
         "type": "object",
         "properties": {
@@ -4953,6 +5280,52 @@
           "data"
         ]
       },
+      "UpdateScheduleInput_2024_06_11": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "example": "One-on-one coaching"
+          },
+          "timeZone": {
+            "type": "string",
+            "example": "Europe/Rome"
+          },
+          "availability": {
+            "example": [
+              {
+                "days": [
+                  "Monday",
+                  "Tuesday"
+                ],
+                "startTime": "09:00",
+                "endTime": "10:00"
+              }
+            ],
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/ScheduleAvailabilityInput_2024_06_11"
+            }
+          },
+          "isDefault": {
+            "type": "boolean",
+            "example": true
+          },
+          "overrides": {
+            "example": [
+              {
+                "date": "2024-05-20",
+                "startTime": "12:00",
+                "endTime": "14:00"
+              }
+            ],
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/ScheduleOverrideInput_2024_06_11"
+            }
+          }
+        }
+      },
       "UpdateScheduleOutput_2024_06_11": {
         "type": "object",
         "properties": {
@@ -5448,6 +5821,492 @@
           "data"
         ]
       },
+      "CreateTeamEventTypeInput_2024_06_14": {
+        "type": "object",
+        "properties": {
+          "lengthInMinutes": {
+            "type": "number",
+            "example": 60
+          },
+          "title": {
+            "type": "string",
+            "example": "Learn the secrets of masterchief!"
+          },
+          "description": {
+            "type": "string",
+            "example": "Discover the culinary wonders of the Argentina by making the best flan ever!"
+          },
+          "locations": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "bookingFields": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "disableGuests": {
+            "type": "boolean"
+          },
+          "slotInterval": {
+            "type": "number"
+          },
+          "minimumBookingNotice": {
+            "type": "number"
+          },
+          "beforeEventBuffer": {
+            "type": "number"
+          },
+          "afterEventBuffer": {
+            "type": "number"
+          },
+          "schedulingType": {
+            "type": "object"
+          },
+          "hosts": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "assignAllTeamMembers": {
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "lengthInMinutes",
+          "title",
+          "description",
+          "locations",
+          "bookingFields",
+          "disableGuests",
+          "slotInterval",
+          "minimumBookingNotice",
+          "beforeEventBuffer",
+          "afterEventBuffer",
+          "schedulingType",
+          "hosts",
+          "assignAllTeamMembers"
+        ]
+      },
+      "CreateTeamEventTypeOutput": {
+        "type": "object",
+        "properties": {
+          "status": {
+            "type": "string",
+            "example": "success",
+            "enum": [
+              "success",
+              "error"
+            ]
+          },
+          "data": {
+            "oneOf": [
+              {
+                "$ref": "#/components/schemas/TeamEventTypeOutput_2024_06_14"
+              },
+              {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/TeamEventTypeOutput_2024_06_14"
+                }
+              }
+            ]
+          }
+        },
+        "required": [
+          "status",
+          "data"
+        ]
+      },
+      "RecurringEvent_2024_06_14": {
+        "type": "object",
+        "properties": {
+          "dtstart": {
+            "format": "date-time",
+            "type": "string"
+          },
+          "interval": {
+            "type": "number"
+          },
+          "count": {
+            "type": "number"
+          },
+          "freq": {
+            "type": "number",
+            "enum": [
+              0,
+              1,
+              2,
+              3,
+              4,
+              5,
+              6
+            ]
+          },
+          "until": {
+            "format": "date-time",
+            "type": "string"
+          },
+          "tzid": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "interval",
+          "count",
+          "freq"
+        ]
+      },
+      "Schedule_2024_06_14": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "number"
+          },
+          "timeZone": {
+            "type": "string",
+            "nullable": true
+          }
+        },
+        "required": [
+          "id",
+          "timeZone"
+        ]
+      },
+      "Host": {
+        "type": "object",
+        "properties": {
+          "userId": {
+            "type": "number"
+          },
+          "mandatory": {
+            "type": "boolean",
+            "default": false
+          },
+          "priority": {
+            "type": "object",
+            "default": "medium"
+          }
+        },
+        "required": [
+          "userId"
+        ]
+      },
+      "TeamEventTypeOutput_2024_06_14": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "number",
+            "example": 1
+          },
+          "lengthInMinutes": {
+            "type": "number",
+            "minimum": 1
+          },
+          "title": {
+            "type": "string"
+          },
+          "slug": {
+            "type": "string"
+          },
+          "description": {
+            "type": "string"
+          },
+          "locations": {
+            "type": "array",
+            "items": {
+              "type": "object"
+            }
+          },
+          "bookingFields": {
+            "type": "array",
+            "items": {
+              "type": "object"
+            }
+          },
+          "disableGuests": {
+            "type": "boolean"
+          },
+          "slotInterval": {
+            "type": "number",
+            "nullable": true
+          },
+          "minimumBookingNotice": {
+            "type": "number",
+            "minimum": 0
+          },
+          "beforeEventBuffer": {
+            "type": "number"
+          },
+          "afterEventBuffer": {
+            "type": "number"
+          },
+          "schedulingType": {
+            "type": "object",
+            "nullable": true
+          },
+          "recurringEvent": {
+            "nullable": true,
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/RecurringEvent_2024_06_14"
+              }
+            ]
+          },
+          "metadata": {
+            "type": "object"
+          },
+          "requiresConfirmation": {
+            "type": "boolean"
+          },
+          "price": {
+            "type": "number"
+          },
+          "currency": {
+            "type": "string"
+          },
+          "lockTimeZoneToggleOnBookingPage": {
+            "type": "boolean"
+          },
+          "seatsPerTimeSlot": {
+            "type": "number",
+            "nullable": true
+          },
+          "forwardParamsSuccessRedirect": {
+            "type": "boolean",
+            "nullable": true
+          },
+          "successRedirectUrl": {
+            "type": "string",
+            "nullable": true
+          },
+          "seatsShowAvailabilityCount": {
+            "type": "boolean",
+            "nullable": true
+          },
+          "isInstantEvent": {
+            "type": "boolean"
+          },
+          "schedule": {
+            "nullable": true,
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/Schedule_2024_06_14"
+              }
+            ]
+          },
+          "teamId": {
+            "type": "number",
+            "nullable": true
+          },
+          "ownerId": {
+            "type": "number",
+            "nullable": true
+          },
+          "parentEventTypeId": {
+            "type": "number",
+            "nullable": true
+          },
+          "hosts": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/Host"
+            }
+          },
+          "assignAllTeamMembers": {
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "id",
+          "lengthInMinutes",
+          "title",
+          "slug",
+          "description",
+          "locations",
+          "bookingFields",
+          "disableGuests",
+          "schedulingType",
+          "recurringEvent",
+          "metadata",
+          "requiresConfirmation",
+          "price",
+          "currency",
+          "lockTimeZoneToggleOnBookingPage",
+          "seatsPerTimeSlot",
+          "forwardParamsSuccessRedirect",
+          "successRedirectUrl",
+          "seatsShowAvailabilityCount",
+          "isInstantEvent",
+          "schedule",
+          "hosts"
+        ]
+      },
+      "GetTeamEventTypeOutput": {
+        "type": "object",
+        "properties": {
+          "status": {
+            "type": "string",
+            "example": "success",
+            "enum": [
+              "success",
+              "error"
+            ]
+          },
+          "data": {
+            "$ref": "#/components/schemas/TeamEventTypeOutput_2024_06_14"
+          }
+        },
+        "required": [
+          "status",
+          "data"
+        ]
+      },
+      "GetTeamEventTypesOutput": {
+        "type": "object",
+        "properties": {
+          "status": {
+            "type": "string",
+            "example": "success",
+            "enum": [
+              "success",
+              "error"
+            ]
+          },
+          "data": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/TeamEventTypeOutput_2024_06_14"
+            }
+          }
+        },
+        "required": [
+          "status",
+          "data"
+        ]
+      },
+      "UpdateTeamEventTypeInput_2024_06_14": {
+        "type": "object",
+        "properties": {
+          "lengthInMinutes": {
+            "type": "number"
+          },
+          "title": {
+            "type": "string"
+          },
+          "slug": {
+            "type": "string"
+          },
+          "description": {
+            "type": "string"
+          },
+          "locations": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "bookingFields": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "disableGuests": {
+            "type": "boolean"
+          },
+          "slotInterval": {
+            "type": "number"
+          },
+          "minimumBookingNotice": {
+            "type": "number"
+          },
+          "beforeEventBuffer": {
+            "type": "number"
+          },
+          "afterEventBuffer": {
+            "type": "number"
+          },
+          "hosts": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "assignAllTeamMembers": {
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "lengthInMinutes",
+          "title",
+          "slug",
+          "description",
+          "locations",
+          "bookingFields",
+          "disableGuests",
+          "slotInterval",
+          "minimumBookingNotice",
+          "beforeEventBuffer",
+          "afterEventBuffer",
+          "hosts",
+          "assignAllTeamMembers"
+        ]
+      },
+      "UpdateTeamEventTypeOutput": {
+        "type": "object",
+        "properties": {
+          "status": {
+            "type": "string",
+            "example": "success",
+            "enum": [
+              "success",
+              "error"
+            ]
+          },
+          "data": {
+            "oneOf": [
+              {
+                "$ref": "#/components/schemas/TeamEventTypeOutput_2024_06_14"
+              },
+              {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/TeamEventTypeOutput_2024_06_14"
+                }
+              }
+            ]
+          }
+        },
+        "required": [
+          "status",
+          "data"
+        ]
+      },
+      "DeleteTeamEventTypeOutput": {
+        "type": "object",
+        "properties": {
+          "status": {
+            "type": "string",
+            "example": "success",
+            "enum": [
+              "success",
+              "error"
+            ]
+          },
+          "data": {
+            "type": "object"
+          }
+        },
+        "required": [
+          "status",
+          "data"
+        ]
+      },
       "OrgTeamMembershipOutputDto": {
         "type": "object",
         "properties": {
@@ -5577,6 +6436,26 @@
           "userId"
         ]
       },
+      "GetDefaultScheduleOutput_2024_06_11": {
+        "type": "object",
+        "properties": {
+          "status": {
+            "type": "string",
+            "example": "success",
+            "enum": [
+              "success",
+              "error"
+            ]
+          },
+          "data": {
+            "$ref": "#/components/schemas/ScheduleOutput_2024_06_11"
+          }
+        },
+        "required": [
+          "status",
+          "data"
+        ]
+      },
       "CreateAvailabilityInput_2024_04_15": {
         "type": "object",
         "properties": {
@@ -5874,6 +6753,66 @@
           "data"
         ]
       },
+      "UpdateScheduleInput_2024_04_15": {
+        "type": "object",
+        "properties": {
+          "timeZone": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          },
+          "isDefault": {
+            "type": "boolean"
+          },
+          "schedule": {
+            "example": [
+              [],
+              [
+                {
+                  "start": "2022-01-01T00:00:00.000Z",
+                  "end": "2022-01-02T00:00:00.000Z"
+                }
+              ],
+              [],
+              [],
+              [],
+              [],
+              []
+            ],
+            "items": {
+              "type": "array"
+            },
+            "type": "array"
+          },
+          "dateOverrides": {
+            "example": [
+              [],
+              [
+                {
+                  "start": "2022-01-01T00:00:00.000Z",
+                  "end": "2022-01-02T00:00:00.000Z"
+                }
+              ],
+              [],
+              [],
+              [],
+              [],
+              []
+            ],
+            "items": {
+              "type": "array"
+            },
+            "type": "array"
+          }
+        },
+        "required": [
+          "timeZone",
+          "name",
+          "isDefault",
+          "schedule"
+        ]
+      },
       "EventTypeModel_2024_04_15": {
         "type": "object",
         "properties": {

apps/api/v2/test/fixtures/repository/event-types.repository.fixture.ts

@@ -21,6 +21,14 @@ export class EventTypesRepositoryFixture {
     });
   }
 
+  async getAllTeamEventTypes(teamId: number) {
+    return this.prismaWriteClient.eventType.findMany({
+      where: {
+        teamId,
+      },
+    });
+  }
+
   async create(
     data: Pick<CreateEventTypeInput_2024_04_15, "title" | "slug" | "length" | "hidden">,
     userId: number

apps/api/v2/test/mocks/api-auth-mock.strategy.ts

@@ -11,7 +11,7 @@ export class ApiAuthMockStrategy extends PassportStrategy(BaseStrategy, "api-aut
 
   async authenticate() {
     try {
-      const user = await this.usersRepository.findByEmail(this.email);
+      const user = await this.usersRepository.findByEmailWithProfile(this.email);
       if (!user) {
         throw new Error("User with the provided ID not found");
       }

packages/platform/types/api.ts

@@ -1,14 +1,11 @@
 import { ApiProperty } from "@nestjs/swagger";
 import { Transform } from "class-transformer";
 import { IsNumber, Min, Max, IsOptional } from "class-validator";
+import { IsEnum } from "class-validator";
 import type { Response as BaseResponse } from "express";
 
-import type {
-  ERROR_STATUS,
-  SUCCESS_STATUS,
-  API_ERROR_CODES,
-  REDIRECT_STATUS,
-} from "@calcom/platform-constants";
+import { ERROR_STATUS, SUCCESS_STATUS } from "@calcom/platform-constants";
+import type { API_ERROR_CODES, REDIRECT_STATUS } from "@calcom/platform-constants";
 
 export type ApiSuccessResponse<T> = { status: typeof SUCCESS_STATUS; data: T };
 export type ApiSuccessResponseWithoutData = { status: typeof SUCCESS_STATUS };
@@ -75,3 +72,9 @@ export class SkipTakePagination {
   @IsOptional()
   skip?: number;
 }
+
+export class ApiResponseWithoutData {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+}

packages/platform/types/event-types/event-types_2024_06_14/inputs/create-event-type.input.ts

@@ -1,8 +1,19 @@
 import { ApiProperty as DocsProperty } from "@nestjs/swagger";
-import { IsString, IsInt, IsBoolean, IsOptional, Min } from "class-validator";
+import { Type } from "class-transformer";
+import {
+  IsString,
+  IsInt,
+  IsBoolean,
+  IsOptional,
+  Min,
+  IsEnum,
+  IsArray,
+  ValidateNested,
+} from "class-validator";
 
 import type { BookingField_2024_06_14 } from "./booking-fields.input";
 import { ValidateBookingFields_2024_06_14 } from "./booking-fields.input";
+import { SchedulingType } from "./enums/scheduling-type";
 import { ValidateLocations_2024_06_14 } from "./locations.input";
 import type { Location_2024_06_14 } from "./locations.input";
 
@@ -10,6 +21,7 @@ export const CREATE_EVENT_LENGTH_EXAMPLE = 60;
 export const CREATE_EVENT_TITLE_EXAMPLE = "Learn the secrets of masterchief!";
 export const CREATE_EVENT_DESCRIPTION_EXAMPLE =
   "Discover the culinary wonders of the Argentina by making the best flan ever!";
+
 export class CreateEventTypeInput_2024_06_14 {
   @IsInt()
   @Min(1)
@@ -57,3 +69,93 @@ export class CreateEventTypeInput_2024_06_14 {
   @IsOptional()
   afterEventBuffer?: number;
 }
+
+export enum HostPriority {
+  lowest = "lowest",
+  low = "low",
+  medium = "medium",
+  high = "high",
+  highest = "highest",
+}
+export class Host {
+  @IsInt()
+  userId!: number;
+
+  @IsOptional()
+  @IsBoolean()
+  mandatory?: boolean = false;
+
+  @IsEnum(HostPriority)
+  @IsOptional()
+  priority?: keyof typeof HostPriority = "medium";
+}
+
+export class CreateTeamEventTypeInput_2024_06_14 {
+  @IsInt()
+  @Min(1)
+  @DocsProperty({ example: CREATE_EVENT_LENGTH_EXAMPLE })
+  lengthInMinutes!: number;
+
+  @IsString()
+  @DocsProperty({ example: CREATE_EVENT_TITLE_EXAMPLE })
+  title!: string;
+
+  @IsString()
+  slug!: string;
+
+  @IsOptional()
+  @IsString()
+  @DocsProperty({ example: CREATE_EVENT_DESCRIPTION_EXAMPLE })
+  description?: string;
+
+  @IsOptional()
+  @ValidateLocations_2024_06_14()
+  @DocsProperty()
+  locations?: Location_2024_06_14[];
+
+  @IsOptional()
+  @ValidateBookingFields_2024_06_14()
+  @DocsProperty()
+  bookingFields?: BookingField_2024_06_14[];
+
+  @IsBoolean()
+  @IsOptional()
+  @DocsProperty()
+  disableGuests?: boolean;
+
+  @IsInt()
+  @IsOptional()
+  @DocsProperty()
+  slotInterval?: number;
+
+  @IsInt()
+  @Min(0)
+  @IsOptional()
+  @DocsProperty()
+  minimumBookingNotice?: number;
+
+  @IsInt()
+  @IsOptional()
+  @DocsProperty()
+  beforeEventBuffer?: number;
+
+  @IsInt()
+  @IsOptional()
+  @DocsProperty()
+  afterEventBuffer?: number;
+
+  @IsEnum(SchedulingType)
+  @DocsProperty()
+  schedulingType!: keyof typeof SchedulingType;
+
+  @ValidateNested({ each: true })
+  @Type(() => Host)
+  @IsArray()
+  @DocsProperty()
+  hosts!: Host[];
+
+  @IsBoolean()
+  @IsOptional()
+  @DocsProperty()
+  assignAllTeamMembers?: boolean;
+}

packages/platform/types/event-types/event-types_2024_06_14/inputs/update-event-type.input.ts

@@ -1,7 +1,10 @@
-import { IsString, IsInt, IsBoolean, IsOptional, Min } from "class-validator";
+import { ApiProperty as DocsProperty } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsString, IsInt, IsBoolean, IsOptional, Min, ValidateNested, IsArray } from "class-validator";
 
 import type { BookingField_2024_06_14 } from "./booking-fields.input";
 import { ValidateBookingFields_2024_06_14 } from "./booking-fields.input";
+import { Host } from "./create-event-type.input";
 import { ValidateLocations_2024_06_14 } from "./locations.input";
 import type { Location_2024_06_14 } from "./locations.input";
 
@@ -15,6 +18,10 @@ export class UpdateEventTypeInput_2024_06_14 {
   @IsString()
   title?: string;
 
+  @IsString()
+  @IsOptional()
+  slug?: string;
+
   @IsOptional()
   @IsString()
   description?: string;
@@ -48,3 +55,73 @@ export class UpdateEventTypeInput_2024_06_14 {
   @IsOptional()
   afterEventBuffer?: number;
 }
+export class UpdateTeamEventTypeInput_2024_06_14 {
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @DocsProperty()
+  lengthInMinutes?: number;
+
+  @IsOptional()
+  @IsString()
+  @DocsProperty()
+  title?: string;
+
+  @IsString()
+  @IsOptional()
+  @DocsProperty()
+  slug?: string;
+
+  @IsOptional()
+  @IsString()
+  @DocsProperty()
+  description?: string;
+
+  @IsOptional()
+  @ValidateLocations_2024_06_14()
+  @DocsProperty()
+  locations?: Location_2024_06_14[];
+
+  @IsOptional()
+  @ValidateBookingFields_2024_06_14()
+  @DocsProperty()
+  bookingFields?: BookingField_2024_06_14[];
+
+  @IsBoolean()
+  @IsOptional()
+  @DocsProperty()
+  disableGuests?: boolean;
+
+  @IsInt()
+  @IsOptional()
+  @DocsProperty()
+  slotInterval?: number;
+
+  @IsInt()
+  @Min(0)
+  @IsOptional()
+  @DocsProperty()
+  minimumBookingNotice?: number;
+
+  @IsInt()
+  @IsOptional()
+  @DocsProperty()
+  beforeEventBuffer?: number;
+
+  @IsInt()
+  @IsOptional()
+  @DocsProperty()
+  afterEventBuffer?: number;
+
+  @ValidateNested({ each: true })
+  @Type(() => Host)
+  @IsArray()
+  @IsOptional()
+  @DocsProperty()
+  hosts?: Host[];
+
+  @IsBoolean()
+  @IsOptional()
+  @DocsProperty()
+  assignAllTeamMembers?: boolean;
+}

packages/platform/types/event-types/event-types_2024_06_14/outputs/event-type.output.ts

@@ -1,8 +1,18 @@
 import { ApiProperty as DocsProperty } from "@nestjs/swagger";
 import { Type } from "class-transformer";
-import { IsBoolean, IsEnum, IsInt, IsOptional, IsString, Min } from "class-validator";
+import {
+  IsArray,
+  IsBoolean,
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+  Min,
+  ValidateNested,
+} from "class-validator";
 
 import type { Location_2024_06_14, BookingField_2024_06_14 } from "../inputs";
+import { Host } from "../inputs";
 import { RecurringEvent_2024_06_14 } from "../inputs";
 import { ValidateBookingFields_2024_06_14 } from "../inputs/booking-fields.input";
 import { ValidateLocations_2024_06_14 } from "../inputs/locations.input";
@@ -135,3 +145,107 @@ export class EventTypeOutput_2024_06_14 {
 
   schedule!: Schedule_2024_06_14 | null;
 }
+
+export class TeamEventTypeOutput_2024_06_14 {
+  @IsInt()
+  @DocsProperty({ example: 1 })
+  id!: number;
+
+  @IsInt()
+  @Min(1)
+  lengthInMinutes!: number;
+
+  @IsString()
+  title!: string;
+
+  @IsString()
+  slug!: string;
+
+  @IsString()
+  description!: string;
+
+  @ValidateLocations_2024_06_14()
+  locations!: Location_2024_06_14[];
+
+  @ValidateBookingFields_2024_06_14()
+  bookingFields!: BookingField_2024_06_14[];
+
+  @IsBoolean()
+  disableGuests!: boolean;
+
+  @IsInt()
+  @IsOptional()
+  slotInterval?: number | null;
+
+  @IsInt()
+  @Min(0)
+  @IsOptional()
+  minimumBookingNotice?: number;
+
+  @IsInt()
+  @IsOptional()
+  beforeEventBuffer?: number;
+
+  @IsInt()
+  @IsOptional()
+  afterEventBuffer?: number;
+
+  @IsEnum(SchedulingTypeEnum)
+  schedulingType!: SchedulingType | null;
+
+  @Type(() => RecurringEvent_2024_06_14)
+  recurringEvent!: RecurringEvent_2024_06_14 | null;
+
+  @Type(() => Object)
+  metadata!: Record<string, unknown>;
+
+  @IsBoolean()
+  requiresConfirmation!: boolean;
+
+  @IsInt()
+  price!: number;
+
+  @IsString()
+  currency!: string;
+
+  @IsBoolean()
+  lockTimeZoneToggleOnBookingPage!: boolean;
+
+  @IsInt()
+  seatsPerTimeSlot!: number | null;
+
+  @IsBoolean()
+  forwardParamsSuccessRedirect!: boolean | null;
+
+  @IsString()
+  successRedirectUrl!: string | null;
+
+  @IsBoolean()
+  seatsShowAvailabilityCount!: boolean | null;
+
+  @IsBoolean()
+  isInstantEvent!: boolean;
+
+  schedule!: Schedule_2024_06_14 | null;
+
+  @IsInt()
+  @IsOptional()
+  teamId?: number | null;
+
+  @IsInt()
+  @IsOptional()
+  ownerId?: number | null;
+
+  @IsInt()
+  @IsOptional()
+  parentEventTypeId?: number | null;
+
+  @ValidateNested({ each: true })
+  @Type(() => Host)
+  @IsArray()
+  hosts!: Host[];
+
+  @IsBoolean()
+  @IsOptional()
+  assignAllTeamMembers?: boolean;
+}