chore: v4.3.2 (#15879)

* Update feature_request.md

* Update .github/ISSUE_TEMPLATE/feature_request.md

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,39 +1,81 @@
----
 name: Bug report
-about: Report any issues with the platform
+description: "Found a bug? Please fill out the sections below. \U0001F44D"
 title: ""
-labels: bug
+labels: 🐛 bug
-assignees: ""
+assignees: []
----
+body:
-
+- type: textarea
-Found a bug? Please fill out the sections below. 👍
+  id: issue-summary
-
+  attributes:
-### Issue Summary
+    label: Issue Summary
-
+    description: A summary of the issue. This needs to be a clear detailed-rich summary.
-A summary of the issue. This needs to be a clear detailed-rich summary.
+  validations:
-
+    required: true
-### Steps to Reproduce
+- type: textarea
-
+  id: steps-to-reproduce
-1. (for example) Went to ...
+  attributes:
-2. Clicked on...
+    label: Steps to Reproduce
-3. ...
+    value: |
-
+      1. (for example) Went to ...
-Any other relevant information. For example, why do you consider this a bug and what did you expect to happen instead?
+      2. Clicked on...
-
+      3. ...
-### Actual Results
+  validations:
-
+    required: true
-- What's happening right now that is different from what is expected
+- type: textarea
-
+  id: expected-behavior
-### Expected Results
+  attributes:
-
+    label: Expected behavior
-- This is an ideal result that the system should get after the tests are performed
+    description: A clear and concise description of what you expected to happen.
-
+  validations:
-### Technical details
+    required: true
-
+- type: textarea
-- Browser version, screen recording, console logs, network requests: You can make a recording with [Bird Eats Bug](https://birdeatsbug.com/).
+  id: other-information
-- Node.js version
+  attributes:
-- Anything else that you think could be an issue.
+    label: Other information
-
+  validations:
-### Evidence
+    required: false
-
+- type: textarea
-- How was this tested? This is quite mandatory in terms of bugs. Providing evidence of your testing with screenshots or/and videos is an amazing way to prove the bug and a troubleshooting chance to find the solution.
+  id: screenshots
+  attributes:
+    label: Screenshots
+    description: If applicable, add screenshots to help explain your problem.
+  validations:
+    required: false
+- type: checkboxes
+  id: environment
+  attributes:
+    label: Environment
+    options:
+      - label: app.cal.com
+      - label: Self-hosted Cal
+- type: textarea
+  id: desktop-version
+  attributes:
+    label: Desktop (please complete the following information)
+    description: | 
+      examples: 
+      - **OS**: [e.g. iOS]
+      - **Browser**: [e.g. chrome, safari]
+      - **Version**: [e.g. 22]
+    value: |
+      - OS:
+      - Node:
+      - npm: 
+    render: markdown
+  validations:
+    required: true
+- type: markdown
+  id: nodejs-version
+  attributes:
+    value: | 
+      #### Node.JS version
+      
+      [e.g. v18.15.0] 
+- type: markdown
+  id: anything-else
+  attributes:
+    value: |
+      #### Anything else?
+      
+      - Screen recording, console logs, network requests: You can make a recording with [Loom](https://www.loom.com).
+      - Anything else that you think could be an issue?

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,55 +1,41 @@
----
 name: Feature request
-about: Suggest a feature or idea
+description: "Suggest an idea for this project \U0001F680"
 title: ""
-labels: feature
+labels: ["✨ feature", "🚨 needs approval"], 
-assignees: ""
+assignees: []
----
+body:
+  - type: textarea
+    id: problem-description
+    attributes:
+      label: Is your feature request related to a problem? Please describe.
+      description: A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+    validations:
+      required: true
+  - type: textarea
+    id: solution-description
+    attributes:
+      label: Describe the solution you'd like
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: alternate-solution-description
+    attributes:
+      label: Describe alternatives you've considered
+      description: A clear and concise description of any alternative solutions or features you've considered.
+    validations:
+      required: false
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional context
+      description: Add any other context or screenshots about the feature request here.
+    validations:
+      required: false
+  - type: markdown
+    id: cal-info
+    attributes:
+      value: |
+        ### How we code at Cal.com
 
-### Is your proposal related to a problem?
+        - Follow Best Practices lined out in our [Contributor Docs](https://github.com/calcom/cal.com/blob/main/CONTRIBUTING.md)
-
-<!--
-  Provide a clear and concise description of what the problem is.
-  For example, "I'm always frustrated when..."
--->
-
-(Write your answer here.)
-
-### Describe the solution you'd like
-
-<!--
-  Provide a clear and concise description of what you want to happen.
--->
-
-(Describe your proposed solution here.)
-
-### Describe alternatives you've considered
-
-<!--
-  Let us know about other solutions you've tried or researched.
--->
-
-(Write your answer here.)
-
-### Additional context
-
-<!--
-  Is there anything else you can add about the proposal?
-  You might want to link to related issues here, if you haven't already.
--->
-
-(Write your answer here.)
-
-### Requirement/Document
-
-<!--
-  Is there any type of document that could support that feature?
--->
-
-(Share it here.)
-
----
-##### House rules
-- If this issue has a `🚨 needs approval` label, don't start coding yet. Wait until a core member approves feature request by removing this label, then you can start coding.
-  - For clarity: Non-core member issues automatically get the `🚨 needs approval` label.
-  - Your feature ideas are invaluable to us! However, they undergo review to ensure alignment with the product's direction.

apps/ai/.env.example

@@ -0,0 +1,21 @@
+BACKEND_URL=http://localhost:3002/api
+# BACKEND_URL=https://api.cal.com/v1
+FRONTEND_URL=http://localhost:3000
+# FRONTEND_URL=https://cal.com
+
+APP_ID=cal-ai
+APP_URL=http://localhost:3000/apps/cal-ai
+
+# This is for the onboard route. Which domain should we send emails from?
+SENDER_DOMAIN=cal.ai
+
+# Used to verify requests from sendgrid. You can generate a new one with: `openssl rand -hex 32`
+PARSE_KEY=
+
+OPENAI_API_KEY=
+
+# Optionally trace completions at https://smith.langchain.com
+# LANGCHAIN_TRACING_V2=true
+# LANGCHAIN_ENDPOINT=
+# LANGCHAIN_API_KEY=
+# LANGCHAIN_PROJECT=

apps/ai/README.md

@@ -0,0 +1,68 @@
+# Cal.ai
+
+Welcome to [Cal.ai](https://cal.ai)!
+
+This app lets you chat with your calendar via email:
+
+- Turn informal emails into bookings eg. forward "wanna meet tmrw at 2pm?"
+- List and rearrange your bookings eg. "clear my afternoon"
+- Answer basic questions about your busiest times eg. "how does my Tuesday look?"
+
+The core logic is contained in [agent/route.ts](/apps/ai/src/app/api/agent/route.ts). Here, a [LangChain Agent Executor](https://docs.langchain.com/docs/components/agents/agent-executor) is tasked with following your instructions. Given your last-known timezone, working hours, and busy times, it attempts to CRUD your bookings.
+
+_The AI agent can only choose from a set of tools, without ever seeing your API key._
+
+Emails are cleaned and routed in [receive/route.ts](/apps/ai/src/app/api/receive/route.ts) using [MailParser](https://nodemailer.com/extras/mailparser/).
+
+Incoming emails are routed by email address. Addresses are verified by [DKIM record](https://support.google.com/a/answer/174124?hl=en), making them hard to spoof.
+
+## Recognition
+
+<a href="https://www.producthunt.com/posts/cal-ai?utm_source=badge-top-post-badge&utm_medium=badge&utm_souce=badge-cal&#0045;ai" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/top-post-badge.svg?post_id=419860&theme=light&period=daily" alt="Cal&#0046;ai - World&#0039;s&#0032;first&#0032;open&#0032;source&#0032;AI&#0032;scheduling&#0032;assistant | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a> <a href="https://www.producthunt.com/posts/cal-ai?utm_source=badge-featured&utm_medium=badge&utm_souce=badge-cal&#0045;ai" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/featured.svg?post_id=419860&theme=light" alt="Cal&#0046;ai - World&#0039;s&#0032;first&#0032;open&#0032;source&#0032;AI&#0032;scheduling&#0032;assistant | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a>
+
+## Getting Started
+
+### Development
+
+If you haven't yet, please run the [root setup](/README.md) steps.
+
+Before running the app, please see [env.mjs](./src/env.mjs) for all required environment variables. Run `cp .env.example .env` in this folder to get started. You'll need:
+
+- An [OpenAI API key](https://platform.openai.com/account/api-keys) with access to GPT-4
+- A [SendGrid API key](https://app.sendgrid.com/settings/api_keys)
+- A default sender email (for example, `me@dev.example.com`)
+- The Cal.ai app's ID and URL (see [add.ts](/packages/app-store/cal-ai/api/index.ts))
+- A unique value for `PARSE_KEY` with `openssl rand -hex 32`
+
+To stand up the API and AI apps simultaneously, simply run `yarn dev:ai`.
+
+### Agent Architecture
+
+The scheduling agent in [agent/route.ts](/apps/ai/src/app/api/agent/route.ts) calls an LLM (in this case, GPT-4) in a loop to accomplish a multi-step task. We use an [OpenAI Functions agent](https://js.langchain.com/docs/modules/agents/agent_types/openai_functions_agent), which is fine-tuned to output text suited for passing to tools.
+
+Tools (eg. [`createBooking`](/apps/ai/src/tools/createBooking.ts)) are simply JavaScript methods wrapped by Zod schemas, telling the agent what format to output.
+
+Here is the full architecture:
+
+![Cal.ai architecture](/apps/ai/src/public/architecture.png)
+
+### Email Router
+
+To expose the AI app, you can use either [Tunnelmole](https://github.com/robbie-cahill/tunnelmole-client), an open source tunnelling tool; or [nGrok](https://ngrok.com/), a popular closed source tunnelling tool. 
+
+For Tunnelmole, run `tmole 3005` (or the AI app's port number) in a new terminal. Please replace `3005` with the port number if it is different. In the output, you'll see two URLs, one http and a https (we recommend using the https url for privacy and security). To install Tunnelmole, use `curl -O https://install.tunnelmole.com/8dPBw/install && sudo bash install`. (On Windows, download [tmole.exe](https://tunnelmole.com/downloads/tmole.exe))
+
+For nGrok, run `ngrok http 3005` (or the AI app's port number) in a new terminal. You may need to install nGrok first.
+
+To forward incoming emails to the serverless function at `/agent`, we use [SendGrid's Inbound Parse](https://docs.sendgrid.com/for-developers/parsing-email/setting-up-the-inbound-parse-webhook).
+
+1.  Ensure you have a [SendGrid account](https://signup.sendgrid.com/)
+2.  Ensure you have an authenticated domain. Go to Settings > Sender Authentication > Authenticate. For DNS host, select `I'm not sure`. Click Next and add your domain, eg. `example.com`. Choose Manual Setup. You'll be given three CNAME records to add to your DNS settings, eg. in [Vercel Domains](https://vercel.com/dashboard/domains). After adding those records, click Verify. To troubleshoot, see the [full instructions](https://docs.sendgrid.com/ui/account-and-settings/how-to-set-up-domain-authentication).
+3.  Authorize your domain for email with MX records: one with name `[your domain].com` and value `mx.sendgrid.net.`, and another with name `bounces.[your domain].com` and value `feedback-smtp.us-east-1.amazonses.com`. Set the priority to `10` if prompted.
+4.  Go to Settings > [Inbound Parse](https://app.sendgrid.com/settings/parse) > Add Host & URL. Choose your authenticated domain.
+5.  In the Destination URL field, use the Tunnelmole or ngrok URL from above along with the path, `/api/receive`, and one param, `parseKey`, which lives in [this app's .env](/apps/ai/.env.example) under `PARSE_KEY`. The full URL should look like `https://abc.tunnelmole.net/api/receive?parseKey=ABC-123` or `https://abc.ngrok.io/api/receive?parseKey=ABC-123`.
+6.  Activate "POST the raw, full MIME message".
+7.  Send an email to `[anyUsername]@example.com`. You should see a ping on the Tunnelmole or ngrok listener and server.
+8.  Adjust the logic in [receive/route.ts](/apps/ai/src/app/api/receive/route.ts), save to hot-reload, and send another email to test the behaviour.
+
+Please feel free to improve any part of this architecture!

apps/ai/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/basic-features/typescript for more information.

apps/ai/next.config.js

@@ -0,0 +1,24 @@
+const withBundleAnalyzer = require("@next/bundle-analyzer");
+
+const plugins = [];
+plugins.push(withBundleAnalyzer({ enabled: process.env.ANALYZE === "true" }));
+
+/** @type {import("next").NextConfig} */
+const nextConfig = {
+  async redirects() {
+    return [
+      {
+        source: "/",
+        destination: "https://cal.com/ai",
+        permanent: true,
+      },
+    ];
+  },
+  i18n: {
+    defaultLocale: "en",
+    locales: ["en"],
+  },
+  reactStrictMode: true,
+};
+
+module.exports = () => plugins.reduce((acc, next) => next(acc), nextConfig);

apps/ai/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@calcom/ai",
+  "version": "1.2.1",
+  "private": true,
+  "author": "Cal.com Inc.",
+  "dependencies": {
+    "@calcom/prisma": "*",
+    "@langchain/core": "^0.1.26",
+    "@langchain/openai": "^0.0.14",
+    "@t3-oss/env-nextjs": "^0.6.1",
+    "langchain": "^0.1.17",
+    "mailparser": "^3.6.5",
+    "next": "^13.5.4",
+    "supports-color": "8.1.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/mailparser": "^3.4.0"
+  },
+  "scripts": {
+    "build": "next build",
+    "dev": "next dev -p 3005",
+    "format": "npx prettier . --write",
+    "lint": "eslint . --ext .ts,.js,.tsx,.jsx",
+    "lint:fix": "eslint . --ext .ts,.js,.tsx,.jsx --fix",
+    "start": "next start"
+  }
+}

apps/ai/src/app/api/agent/route.ts

@@ -0,0 +1,55 @@
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+
+import agent from "../../../utils/agent";
+import sendEmail from "../../../utils/sendEmail";
+import { verifyParseKey } from "../../../utils/verifyParseKey";
+
+// Allow agent loop to run for up to 5 minutes
+export const maxDuration = 300;
+
+/**
+ * Launches a LangChain agent to process an incoming email,
+ * then sends the response to the user.
+ */
+export const POST = async (request: NextRequest) => {
+  const verified = verifyParseKey(request.url);
+
+  if (!verified) {
+    return new NextResponse("Unauthorized", { status: 401 });
+  }
+
+  const json = await request.json();
+
+  const { apiKey, userId, message, subject, user, users, replyTo: agentEmail } = json;
+
+  if ((!message && !subject) || !user) {
+    return new NextResponse("Missing fields", { status: 400 });
+  }
+
+  try {
+    const response = await agent(`${subject}\n\n${message}`, { ...user }, users, apiKey, userId, agentEmail);
+
+    // Send response to user
+    await sendEmail({
+      subject: `Re: ${subject}`,
+      text: response.replace(/(?:\r\n|\r|\n)/g, "\n"),
+      to: user.email,
+      from: agentEmail,
+    });
+
+    return new NextResponse("ok");
+  } catch (error) {
+    await sendEmail({
+      subject: `Re: ${subject}`,
+      text: "Thanks for using Cal.ai! We're experiencing high demand and can't currently process your request. Please try again later.",
+      to: user.email,
+      from: agentEmail,
+    });
+
+    return new NextResponse(
+      (error as Error).message || "Something went wrong. Please try again or reach out for help.",
+      { status: 500 }
+    );
+  }
+};

apps/ai/src/app/api/onboard/route.ts

@@ -0,0 +1,44 @@
+import type { NextRequest } from "next/server";
+
+import prisma from "@calcom/prisma";
+
+import { env } from "../../../env.mjs";
+import sendEmail from "../../../utils/sendEmail";
+
+export const POST = async (request: NextRequest) => {
+  const { userId } = await request.json();
+
+  const user = await prisma.user.findUnique({
+    select: {
+      email: true,
+      name: true,
+      username: true,
+    },
+    where: {
+      id: userId,
+    },
+  });
+
+  if (!user) {
+    return new Response("User not found", { status: 404 });
+  }
+
+  await sendEmail({
+    subject: "Welcome to Cal AI",
+    to: user.email,
+    from: `${user.username}@${env.SENDER_DOMAIN}`,
+    text: `Hi ${
+      user.name || `@${user.username}`
+    },\n\nI'm Cal AI, your personal booking assistant! I'll be here, 24/7 to help manage your busy schedule and find times to meet with the people you care about.\n\nHere are some things you can ask me:\n\n- "Book a meeting with @someone" (The @ symbol lets you tag Cal.com users)\n- "What meetings do I have today?" (I'll show you your schedule)\n- "Find a time for coffee with someone@gmail.com" (I'll intro and send them some good times)\n\nI'm still learning, so if you have any feedback, please tweet it to @calcom!\n\nRemember, you can always reach me here, at ${
+      user.username
+    }@${
+      env.SENDER_DOMAIN
+    }.\n\nLooking forward to working together (:\n\n- Cal AI, Your personal booking assistant`,
+    html: `Hi ${
+      user.name || `@${user.username}`
+    },<br><br>I'm Cal AI, your personal booking assistant! I'll be here, 24/7 to help manage your busy schedule and find times to meet with the people you care about.<br><br>Here are some things you can ask me:<br><br>- "Book a meeting with @someone" (The @ symbol lets you tag Cal.com users)<br>- "What meetings do I have today?" (I'll show you your schedule)<br>- "Find a time for coffee with someone@gmail.com" (I'll intro and send them some good times)<br><br>I'm still learning, so if you have any feedback, please send it to <a href="https://twitter.com/calcom">@calcom</a> on X!<br><br>Remember, you can always reach me here, at ${
+      user.username
+    }@${env.SENDER_DOMAIN}.<br><br>Looking forward to working together (:<br><br>- Cal AI`,
+  });
+  return new Response("OK", { status: 200 });
+};

apps/ai/src/app/api/receive/route.ts

@@ -0,0 +1,186 @@
+import type { ParsedMail, Source } from "mailparser";
+import { simpleParser } from "mailparser";
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+
+import { checkRateLimitAndThrowError } from "@calcom/lib/checkRateLimitAndThrowError";
+import prisma from "@calcom/prisma";
+
+import { env } from "../../../env.mjs";
+import { fetchAvailability } from "../../../tools/getAvailability";
+import { fetchEventTypes } from "../../../tools/getEventTypes";
+import { extractUsers } from "../../../utils/extractUsers";
+import getHostFromHeaders from "../../../utils/host";
+import now from "../../../utils/now";
+import sendEmail from "../../../utils/sendEmail";
+import { verifyParseKey } from "../../../utils/verifyParseKey";
+
+// Allow receive loop to run for up to 30 seconds
+// Why so long? the rate determining API call (getAvailability, getEventTypes) can take up to 15 seconds at peak times so we give it a little extra time to complete.
+export const maxDuration = 30;
+
+/**
+ * Verifies email signature and app authorization,
+ * then hands off to booking agent.
+ */
+export const POST = async (request: NextRequest) => {
+  const verified = verifyParseKey(request.url);
+
+  if (!verified) {
+    return new NextResponse("Unauthorized", { status: 401 });
+  }
+
+  const formData = await request.formData();
+  const body = Object.fromEntries(formData);
+  const envelope = JSON.parse(body.envelope as string);
+
+  const aiEmail = envelope.to[0];
+  const subject = body.subject || "";
+
+  try {
+    await checkRateLimitAndThrowError({
+      identifier: `ai:email:${envelope.from}`,
+      rateLimitingType: "ai",
+    });
+  } catch (error) {
+    await sendEmail({
+      subject: `Re: ${subject}`,
+      text: "Thanks for using Cal.ai! You've reached your daily limit. Please try again tomorrow.",
+      to: envelope.from,
+      from: aiEmail,
+    });
+
+    return new NextResponse("Exceeded rate limit", { status: 200 }); // Don't return 429 to avoid triggering retry logic in SendGrid
+  }
+
+  // Parse email from mixed MIME type
+  const parsed: ParsedMail = await simpleParser(body.email as Source);
+
+  if (!parsed.text && !parsed.subject) {
+    await sendEmail({
+      subject: `Re: ${subject}`,
+      text: "Thanks for using Cal.ai! It looks like you forgot to include a message. Please try again.",
+      to: envelope.from,
+      from: aiEmail,
+    });
+    return new NextResponse("Email missing text and subject", { status: 400 });
+  }
+
+  const user = await prisma.user.findUnique({
+    select: {
+      email: true,
+      id: true,
+      username: true,
+      timeZone: true,
+      credentials: {
+        select: {
+          appId: true,
+          key: true,
+        },
+      },
+    },
+    where: { email: envelope.from },
+  });
+
+  // body.dkim looks like {@domain-com.22222222.gappssmtp.com : pass}
+  const signature = (body.dkim as string).includes(" : pass");
+
+  // User is not a cal.com user or is using an unverified email.
+  if (!signature || !user) {
+    await sendEmail({
+      html: `Thanks for your interest in Cal.ai! To get started, Make sure you have a <a href="https://cal.com/signup" target="_blank">cal.com</a> account with this email address and then install Cal.ai here: <a href="https://go.cal.com/ai" target="_blank">go.cal.com/ai</a>.`,
+      subject: `Re: ${subject}`,
+      text: `Thanks for your interest in Cal.ai! To get started, Make sure you have a cal.com account with this email address. You can sign up for an account at: https://cal.com/signup`,
+      to: envelope.from,
+      from: aiEmail,
+    });
+
+    return new NextResponse("ok");
+  }
+
+  const credential = user.credentials.find((c) => c.appId === env.APP_ID)?.key;
+
+  // User has not installed the app from the app store. Direct them to install it.
+  if (!(credential as { apiKey: string })?.apiKey) {
+    const url = env.APP_URL;
+
+    await sendEmail({
+      html: `Thanks for using Cal.ai! To get started, the app must be installed. <a href=${url} target="_blank">Click this link</a> to install it.`,
+      subject: `Re: ${subject}`,
+      text: `Thanks for using Cal.ai! To get started, the app must be installed. Click this link to install the Cal.ai app: ${url}`,
+      to: envelope.from,
+      from: aiEmail,
+    });
+
+    return new NextResponse("ok");
+  }
+
+  const { apiKey } = credential as { apiKey: string };
+
+  // Pre-fetch data relevant to most bookings.
+  const [eventTypes, availability, users] = await Promise.all([
+    fetchEventTypes({
+      apiKey,
+    }),
+    fetchAvailability({
+      apiKey,
+      userId: user.id,
+      dateFrom: now(user.timeZone),
+      dateTo: now(user.timeZone),
+    }),
+    extractUsers(`${parsed.text} ${parsed.subject}`),
+  ]);
+
+  if ("error" in availability) {
+    await sendEmail({
+      subject: `Re: ${subject}`,
+      text: "Sorry, there was an error fetching your availability. Please try again.",
+      to: user.email,
+      from: aiEmail,
+    });
+    console.error(availability.error);
+    return new NextResponse("Error fetching availability. Please try again.", { status: 400 });
+  }
+
+  if ("error" in eventTypes) {
+    await sendEmail({
+      subject: `Re: ${subject}`,
+      text: "Sorry, there was an error fetching your event types. Please try again.",
+      to: user.email,
+      from: aiEmail,
+    });
+    console.error(eventTypes.error);
+    return new NextResponse("Error fetching event types. Please try again.", { status: 400 });
+  }
+
+  const { workingHours } = availability;
+
+  const appHost = getHostFromHeaders(request.headers);
+
+  // Hand off to long-running agent endpoint to handle the email. (don't await)
+  fetch(`${appHost}/api/agent?parseKey=${env.PARSE_KEY}`, {
+    body: JSON.stringify({
+      apiKey,
+      userId: user.id,
+      message: parsed.text || "",
+      subject: parsed.subject || "",
+      replyTo: aiEmail,
+      user: {
+        email: user.email,
+        eventTypes,
+        username: user.username,
+        timeZone: user.timeZone,
+        workingHours,
+      },
+      users,
+    }),
+    headers: {
+      "Content-Type": "application/json",
+    },
+    method: "POST",
+  });
+
+  await new Promise((r) => setTimeout(r, 1000));
+
+  return new NextResponse("ok");
+};

apps/ai/src/env.mjs

@@ -0,0 +1,47 @@
+import { createEnv } from "@t3-oss/env-nextjs";
+import { z } from "zod";
+
+export const env = createEnv({
+  /**
+   * Specify your client-side environment variables schema here. This way you can ensure the app
+   * isn't built with invalid env vars. To expose them to the client, prefix them with
+   * `NEXT_PUBLIC_`.
+   */
+  client: {
+    // NEXT_PUBLIC_CLIENTVAR: z.string().min(1),
+  },
+
+  /**
+   * You can't destruct `process.env` as a regular object in the Next.js edge runtimes (e.g.
+   * middlewares) or client-side so we need to destruct manually.
+   */
+  runtimeEnv: {
+    BACKEND_URL: process.env.BACKEND_URL,
+    FRONTEND_URL: process.env.FRONTEND_URL,
+    APP_ID: process.env.APP_ID,
+    APP_URL: process.env.APP_URL,
+    SENDER_DOMAIN: process.env.SENDER_DOMAIN,
+    PARSE_KEY: process.env.PARSE_KEY,
+    NODE_ENV: process.env.NODE_ENV,
+    OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+    SENDGRID_API_KEY: process.env.SENDGRID_API_KEY,
+    DATABASE_URL: process.env.DATABASE_URL,
+  },
+
+  /**
+   * Specify your server-side environment variables schema here. This way you can ensure the app
+   * isn't built with invalid env vars.
+   */
+  server: {
+    BACKEND_URL: z.string().url(),
+    FRONTEND_URL: z.string().url(),
+    APP_ID: z.string().min(1),
+    APP_URL: z.string().url(),
+    SENDER_DOMAIN: z.string().min(1),
+    PARSE_KEY: z.string().min(1),
+    NODE_ENV: z.enum(["development", "test", "production"]),
+    OPENAI_API_KEY: z.string().min(1),
+    SENDGRID_API_KEY: z.string().min(1),
+    DATABASE_URL: z.string().url(),
+  },
+});

apps/ai/src/tools/createBooking.ts

@@ -0,0 +1,121 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+
+import type { UserList } from "~/src/types/user";
+
+import { env } from "../env.mjs";
+
+/**
+ * Creates a booking for a user by event type, times, and timezone.
+ */
+const createBooking = async ({
+  apiKey,
+  userId,
+  users,
+  eventTypeId,
+  start,
+  end,
+  timeZone,
+  language,
+  invite,
+}: {
+  apiKey: string;
+  userId: number;
+  users: UserList;
+  eventTypeId: number;
+  start: string;
+  end: string;
+  timeZone: string;
+  language: string;
+  invite: number;
+  title?: string;
+  status?: string;
+}): Promise<string | Error | { error: string }> => {
+  const params = {
+    apiKey,
+    userId: userId.toString(),
+  };
+
+  const urlParams = new URLSearchParams(params);
+
+  const url = `${env.BACKEND_URL}/bookings?${urlParams.toString()}`;
+
+  const user = users.find((u) => u.id === invite);
+
+  if (!user) {
+    return { error: `User with id ${invite} not found to invite` };
+  }
+
+  const responses = {
+    id: invite.toString(),
+    name: user.username,
+    email: user.email,
+  };
+
+  const response = await fetch(url, {
+    body: JSON.stringify({
+      end,
+      eventTypeId,
+      language,
+      metadata: {},
+      responses,
+      start,
+      timeZone,
+    }),
+    headers: {
+      "Content-Type": "application/json",
+    },
+    method: "POST",
+  });
+
+  // Let GPT handle this. This will happen when wrong event type id is used.
+  // if (response.status === 401) throw new Error("Unauthorized");
+
+  const data = await response.json();
+
+  if (response.status !== 200) {
+    return {
+      error: data.message,
+    };
+  }
+
+  return "Booking created";
+};
+
+const createBookingTool = (apiKey: string, userId: number, users: UserList) => {
+  return new DynamicStructuredTool({
+    description: "Creates a booking on the primary user's calendar.",
+    func: async ({ eventTypeId, start, end, timeZone, language, invite, title, status }) => {
+      return JSON.stringify(
+        await createBooking({
+          apiKey,
+          userId,
+          users,
+          end,
+          eventTypeId,
+          language,
+          invite,
+          start,
+          status,
+          timeZone,
+          title,
+        })
+      );
+    },
+    name: "createBooking",
+    schema: z.object({
+      end: z
+        .string()
+        .describe("This should correspond to the event type's length, unless otherwise specified."),
+      eventTypeId: z.number(),
+      language: z.string(),
+      invite: z.number().describe("External user id to invite."),
+      start: z.string(),
+      status: z.string().optional().describe("ACCEPTED, PENDING, CANCELLED or REJECTED"),
+      timeZone: z.string(),
+      title: z.string().optional(),
+    }),
+  });
+};
+
+export default createBookingTool;

apps/ai/src/tools/deleteBooking.ts

@@ -0,0 +1,66 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+
+import { env } from "../env.mjs";
+
+/**
+ * Cancels a booking for a user by ID with reason.
+ */
+const cancelBooking = async ({
+  apiKey,
+  id,
+  reason,
+}: {
+  apiKey: string;
+  id: string;
+  reason: string;
+}): Promise<string | { error: string }> => {
+  const params = {
+    apiKey,
+  };
+
+  const urlParams = new URLSearchParams(params);
+
+  const url = `${env.BACKEND_URL}/bookings/${id}/cancel?${urlParams.toString()}`;
+
+  const response = await fetch(url, {
+    body: JSON.stringify({ reason }),
+    headers: {
+      "Content-Type": "application/json",
+    },
+    method: "DELETE",
+  });
+
+  // Let GPT handle this. This will happen when wrong booking id is used.
+  // if (response.status === 401) throw new Error("Unauthorized");
+
+  const data = await response.json();
+
+  if (response.status !== 200) {
+    return { error: data.message };
+  }
+
+  return "Booking cancelled";
+};
+
+const cancelBookingTool = (apiKey: string) => {
+  return new DynamicStructuredTool({
+    description: "Cancel a booking",
+    func: async ({ id, reason }) => {
+      return JSON.stringify(
+        await cancelBooking({
+          apiKey,
+          id,
+          reason,
+        })
+      );
+    },
+    name: "cancelBooking",
+    schema: z.object({
+      id: z.string(),
+      reason: z.string(),
+    }),
+  });
+};
+
+export default cancelBookingTool;

apps/ai/src/tools/getAvailability.ts

@@ -0,0 +1,77 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+
+import { env } from "../env.mjs";
+import type { Availability } from "../types/availability";
+
+/**
+ * Fetches availability for a user by date range and event type.
+ */
+export const fetchAvailability = async ({
+  apiKey,
+  userId,
+  dateFrom,
+  dateTo,
+}: {
+  apiKey: string;
+  userId: number;
+  dateFrom: string;
+  dateTo: string;
+}): Promise<Partial<Availability> | { error: string }> => {
+  const params: { [k: string]: string } = {
+    apiKey,
+    userId: userId.toString(),
+    dateFrom,
+    dateTo,
+  };
+
+  const urlParams = new URLSearchParams(params);
+
+  const url = `${env.BACKEND_URL}/availability?${urlParams.toString()}`;
+
+  const response = await fetch(url);
+
+  if (response.status === 401) throw new Error("Unauthorized");
+
+  const data = await response.json();
+
+  if (response.status !== 200) {
+    return { error: data.message };
+  }
+
+  return {
+    busy: data.busy,
+    dateRanges: data.dateRanges,
+    timeZone: data.timeZone,
+    workingHours: data.workingHours,
+  };
+};
+
+const getAvailabilityTool = (apiKey: string) => {
+  return new DynamicStructuredTool({
+    description: "Get availability of users within range.",
+    func: async ({ userIds, dateFrom, dateTo }) => {
+      return JSON.stringify(
+        await Promise.all(
+          userIds.map(
+            async (userId) =>
+              await fetchAvailability({
+                userId: userId,
+                apiKey,
+                dateFrom,
+                dateTo,
+              })
+          )
+        )
+      );
+    },
+    name: "getAvailability",
+    schema: z.object({
+      userIds: z.array(z.number()).describe("The users to fetch availability for."),
+      dateFrom: z.string(),
+      dateTo: z.string(),
+    }),
+  });
+};
+
+export default getAvailabilityTool;

apps/ai/src/tools/getBookings.ts

@@ -0,0 +1,75 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+
+import { env } from "../env.mjs";
+import type { Booking } from "../types/booking";
+import { BOOKING_STATUS } from "../types/booking";
+
+/**
+ * Fetches bookings for a user by date range.
+ */
+const fetchBookings = async ({
+  apiKey,
+  userId,
+  from,
+  to,
+}: {
+  apiKey: string;
+  userId: number;
+  from: string;
+  to: string;
+}): Promise<Booking[] | { error: string }> => {
+  const params = {
+    apiKey,
+    userId: userId.toString(),
+    dateFrom: from,
+    dateTo: to,
+  };
+
+  const urlParams = new URLSearchParams(params);
+
+  const url = `${env.BACKEND_URL}/bookings?${urlParams.toString()}`;
+
+  const response = await fetch(url);
+
+  if (response.status === 401) throw new Error("Unauthorized");
+
+  const data = await response.json();
+
+  if (response.status !== 200) {
+    return { error: data.message };
+  }
+
+  const bookings: Booking[] = data.bookings
+    .filter((booking: Booking) => {
+      const notCancelled = booking.status !== BOOKING_STATUS.CANCELLED;
+
+      return notCancelled;
+    })
+    .map(({ endTime, eventTypeId, id, startTime, status, title }: Booking) => ({
+      endTime,
+      eventTypeId,
+      id,
+      startTime,
+      status,
+      title,
+    }));
+
+  return bookings;
+};
+
+const getBookingsTool = (apiKey: string, userId: number) => {
+  return new DynamicStructuredTool({
+    description: "Get bookings for the primary user between two dates.",
+    func: async ({ from, to }) => {
+      return JSON.stringify(await fetchBookings({ apiKey, userId, from, to }));
+    },
+    name: "getBookings",
+    schema: z.object({
+      from: z.string().describe("ISO 8601 datetime string"),
+      to: z.string().describe("ISO 8601 datetime string"),
+    }),
+  });
+};
+
+export default getBookingsTool;

apps/ai/src/tools/getEventTypes.ts

@@ -0,0 +1,59 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+
+import { env } from "../env.mjs";
+import type { EventType } from "../types/eventType";
+
+/**
+ * Fetches event types by user ID.
+ */
+export const fetchEventTypes = async ({ apiKey, userId }: { apiKey: string; userId?: number }) => {
+  const params: Record<string, string> = {
+    apiKey,
+  };
+
+  if (userId) {
+    params["userId"] = userId.toString();
+  }
+
+  const urlParams = new URLSearchParams(params);
+
+  const url = `${env.BACKEND_URL}/event-types?${urlParams.toString()}`;
+
+  const response = await fetch(url);
+
+  if (response.status === 401) throw new Error("Unauthorized");
+
+  const data = await response.json();
+
+  if (response.status !== 200) {
+    return { error: data.message };
+  }
+
+  return data.event_types.map((eventType: EventType) => ({
+    id: eventType.id,
+    slug: eventType.slug,
+    length: eventType.length,
+    title: eventType.title,
+  }));
+};
+
+const getEventTypesTool = (apiKey: string) => {
+  return new DynamicStructuredTool({
+    description: "Get a user's event type IDs. Usually necessary to book a meeting.",
+    func: async ({ userId }) => {
+      return JSON.stringify(
+        await fetchEventTypes({
+          apiKey,
+          userId,
+        })
+      );
+    },
+    name: "getEventTypes",
+    schema: z.object({
+      userId: z.number().optional().describe("The user ID. Defaults to the primary user's ID."),
+    }),
+  });
+};
+
+export default getEventTypesTool;

apps/ai/src/tools/sendBookingEmail.ts

@@ -0,0 +1,124 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+
+import { env } from "~/src/env.mjs";
+import type { User, UserList } from "~/src/types/user";
+import sendEmail from "~/src/utils/sendEmail";
+
+export const sendBookingEmail = async ({
+  user,
+  agentEmail,
+  subject,
+  to,
+  message,
+  eventTypeSlug,
+  slots,
+  date,
+}: {
+  apiKey: string;
+  user: User;
+  users: UserList;
+  agentEmail: string;
+  subject: string;
+  to: string;
+  message: string;
+  eventTypeSlug: string;
+  slots?: {
+    time: string;
+    text: string;
+  }[];
+  date: {
+    date: string;
+    text: string;
+  };
+}) => {
+  // const url = `${env.FRONTEND_URL}/${user.username}/${eventTypeSlug}?date=${date}`;
+  const timeUrls = slots?.map(({ time, text }) => {
+    return {
+      url: `${env.FRONTEND_URL}/${user.username}/${eventTypeSlug}?slot=${time}`,
+      text,
+    };
+  });
+
+  const dateUrl = {
+    url: `${env.FRONTEND_URL}/${user.username}/${eventTypeSlug}?date=${date.date}`,
+    text: date.text,
+  };
+
+  await sendEmail({
+    subject,
+    to,
+    cc: user.email,
+    from: agentEmail,
+    text: message
+      .split("[[[Slots]]]")
+      .join(timeUrls?.map(({ url, text }) => `${text}: ${url}`).join("\n"))
+      .split("[[[Link]]]")
+      .join(`${dateUrl.text}: ${dateUrl.url}`),
+    html: message
+      .split("\n")
+      .join("<br>")
+      .split("[[[Slots]]]")
+      .join(timeUrls?.map(({ url, text }) => `<a href="${url}">${text}</a>`).join("<br>"))
+      .split("[[[Link]]]")
+      .join(`<a href="${dateUrl.url}">${dateUrl.text}</a>`),
+  });
+
+  return "Booking link sent";
+};
+
+const sendBookingEmailTool = (apiKey: string, user: User, users: UserList, agentEmail: string) => {
+  return new DynamicStructuredTool({
+    description:
+      "Send a booking link via email. Useful for scheduling with non cal users. Be confident, suggesting a good date/time with a fallback to a link to select a date/time.",
+    func: async ({ message, subject, to, eventTypeSlug, slots, date }) => {
+      return JSON.stringify(
+        await sendBookingEmail({
+          apiKey,
+          user,
+          users,
+          agentEmail,
+          subject,
+          to,
+          message,
+          eventTypeSlug,
+          slots,
+          date,
+        })
+      );
+    },
+    name: "sendBookingEmail",
+
+    schema: z.object({
+      message: z
+        .string()
+        .describe(
+          "A polite and professional email with an intro and signature at the end. Specify you are the AI booking assistant of the primary user. Use [[[Slots]]] and a fallback [[[Link]]] to inject good times and 'see all times' into messages"
+        ),
+      subject: z.string(),
+      to: z
+        .string()
+        .describe("email address to send the booking link to. Primary user is automatically CC'd"),
+      eventTypeSlug: z.string().describe("the slug of the event type to book"),
+      slots: z
+        .array(
+          z.object({
+            time: z.string().describe("YYYY-MM-DDTHH:mm in UTC"),
+            text: z.string().describe("minimum readable label. Ex. 4pm."),
+          })
+        )
+        .optional()
+        .describe("Time slots the external user can click"),
+      date: z
+        .object({
+          date: z.string().describe("YYYY-MM-DD"),
+          text: z.string().describe('"See all times" or similar'),
+        })
+        .describe(
+          "A booking link that allows the external user to select a date / time. Should be a fallback to time slots"
+        ),
+    }),
+  });
+};
+
+export default sendBookingEmailTool;

apps/ai/src/tools/updateBooking.ts

@@ -0,0 +1,85 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+
+import { env } from "../env.mjs";
+
+/**
+ * Edits a booking for a user by booking ID with new times, title, description, or status.
+ */
+const editBooking = async ({
+  apiKey,
+  userId,
+  id,
+  startTime, // In the docs it says start, but it's startTime: https://cal.com/docs/enterprise-features/api/api-reference/bookings#edit-an-existing-booking.
+  endTime, // Same here: it says end but it's endTime.
+  title,
+  description,
+  status,
+}: {
+  apiKey: string;
+  userId: number;
+  id: string;
+  startTime?: string;
+  endTime?: string;
+  title?: string;
+  description?: string;
+  status?: string;
+}): Promise<string | { error: string }> => {
+  const params = {
+    apiKey,
+    userId: userId.toString(),
+  };
+  const urlParams = new URLSearchParams(params);
+
+  const url = `${env.BACKEND_URL}/bookings/${id}?${urlParams.toString()}`;
+
+  const response = await fetch(url, {
+    body: JSON.stringify({ description, endTime, startTime, status, title }),
+    headers: {
+      "Content-Type": "application/json",
+    },
+    method: "PATCH",
+  });
+
+  // Let GPT handle this. This will happen when wrong booking id is used.
+  // if (response.status === 401) throw new Error("Unauthorized");
+
+  const data = await response.json();
+
+  if (response.status !== 200) {
+    return { error: data.message };
+  }
+
+  return "Booking edited";
+};
+
+const editBookingTool = (apiKey: string, userId: number) => {
+  return new DynamicStructuredTool({
+    description: "Edit a booking",
+    func: async ({ description, endTime, id, startTime, status, title }) => {
+      return JSON.stringify(
+        await editBooking({
+          apiKey,
+          userId,
+          description,
+          endTime,
+          id,
+          startTime,
+          status,
+          title,
+        })
+      );
+    },
+    name: "editBooking",
+    schema: z.object({
+      description: z.string().optional(),
+      endTime: z.string().optional(),
+      id: z.string(),
+      startTime: z.string().optional(),
+      status: z.string().optional(),
+      title: z.string().optional(),
+    }),
+  });
+};
+
+export default editBookingTool;

apps/ai/src/types/availability.ts

@@ -0,0 +1,25 @@
+export type Availability = {
+  busy: {
+    start: string;
+    end: string;
+    title?: string;
+  }[];
+  timeZone: string;
+  dateRanges: {
+    start: string;
+    end: string;
+  }[];
+  workingHours: {
+    days: number[];
+    startTime: number;
+    endTime: number;
+    userId: number;
+  }[];
+  dateOverrides: {
+    date: string;
+    startTime: number;
+    endTime: number;
+    userId: number;
+  };
+  currentSeats: number;
+};

apps/ai/src/types/booking.ts

@@ -0,0 +1,23 @@
+export enum BOOKING_STATUS {
+  ACCEPTED = "ACCEPTED",
+  PENDING = "PENDING",
+  CANCELLED = "CANCELLED",
+  REJECTED = "REJECTED",
+}
+
+export type Booking = {
+  id: number;
+  userId: number;
+  description: string | null;
+  eventTypeId: number;
+  uid: string;
+  title: string;
+  startTime: string;
+  endTime: string;
+  attendees: { email: string; name: string; timeZone: string; locale: string }[] | null;
+  user: { email: string; name: string; timeZone: string; locale: string }[] | null;
+  payment: { id: number; success: boolean; paymentOption: string }[];
+  metadata: object | null;
+  status: BOOKING_STATUS;
+  responses: { email: string; name: string; location: string } | null;
+};

apps/ai/src/types/eventType.ts

@@ -0,0 +1,13 @@
+export type EventType = {
+  id: number;
+  title: string;
+  length: number;
+  metadata: object;
+  slug: string;
+  hosts: {
+    userId: number;
+    isFixed: boolean;
+  }[];
+  hidden: boolean;
+  // ...
+};

apps/ai/src/types/user.ts

@@ -0,0 +1,18 @@
+import type { EventType } from "./eventType";
+import type { WorkingHours } from "./workingHours";
+
+export type User = {
+  id: number;
+  email: string;
+  username: string;
+  timeZone: string;
+  eventTypes: EventType[];
+  workingHours: WorkingHours[];
+};
+
+export type UserList = {
+  id?: number;
+  email?: string;
+  username?: string;
+  type: "fromUsername" | "fromEmail";
+}[];

apps/ai/src/types/workingHours.ts

@@ -0,0 +1,5 @@
+export type WorkingHours = {
+  days: number[];
+  startTime: number;
+  endTime: number;
+};

apps/ai/src/utils/agent.ts

@@ -0,0 +1,122 @@
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { ChatOpenAI } from "@langchain/openai";
+import { AgentExecutor, createOpenAIFunctionsAgent } from "langchain/agents";
+
+import { env } from "../env.mjs";
+import createBookingIfAvailable from "../tools/createBooking";
+import deleteBooking from "../tools/deleteBooking";
+import getAvailability from "../tools/getAvailability";
+import getBookings from "../tools/getBookings";
+import sendBookingEmail from "../tools/sendBookingEmail";
+import updateBooking from "../tools/updateBooking";
+import type { EventType } from "../types/eventType";
+import type { User, UserList } from "../types/user";
+import type { WorkingHours } from "../types/workingHours";
+import now from "./now";
+
+const gptModel = "gpt-4-0125-preview";
+
+/**
+ * Core of the Cal.ai booking agent: a LangChain Agent Executor.
+ * Uses a toolchain to book meetings, list available slots, etc.
+ * Uses OpenAI functions to better enforce JSON-parsable output from the LLM.
+ */
+const agent = async (
+  input: string,
+  user: User,
+  users: UserList,
+  apiKey: string,
+  userId: number,
+  agentEmail: string
+) => {
+  const tools = [
+    // getEventTypes(apiKey),
+    getAvailability(apiKey),
+    getBookings(apiKey, userId),
+    createBookingIfAvailable(apiKey, userId, users),
+    updateBooking(apiKey, userId),
+    deleteBooking(apiKey),
+    sendBookingEmail(apiKey, user, users, agentEmail),
+  ];
+
+  const model = new ChatOpenAI({
+    modelName: gptModel,
+    openAIApiKey: env.OPENAI_API_KEY,
+    temperature: 0,
+  });
+
+  /**
+   * Initialize the agent executor with arguments.
+   */
+  const prompt =
+    ChatPromptTemplate.fromTemplate(`You are Cal.ai - a bleeding edge scheduling assistant that interfaces via email.
+  Make sure your final answers are definitive, complete and well formatted.
+  Sometimes, tools return errors. In this case, try to handle the error intelligently or ask the user for more information.
+  Tools will always handle times in UTC, but times sent to users should be formatted per that user's timezone.
+  In responses to users, always summarize necessary context and open the door to follow ups. For example "I have booked your chat with @username for 3pm on Wednesday, December 20th, 2023 EST. Please let me know if you need to reschedule."
+  If you can't find a referenced user, ask the user for their email or @username. Make sure to specify that usernames require the @username format. Users don't know other users' userIds.
+  
+  The primary user's id is: ${userId}
+  The primary user's username is: ${user.username}
+  The current time in the primary user's timezone is: ${now(user.timeZone, {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+  })}
+  The primary user's time zone is: ${user.timeZone}
+  The primary user's event types are: ${user.eventTypes
+    .map((e: EventType) => `ID: ${e.id}, Slug: ${e.slug}, Title: ${e.title}, Length: ${e.length};`)
+    .join("\n")}
+  The primary user's working hours are: ${user.workingHours
+    .map(
+      (w: WorkingHours) =>
+        `Days: ${w.days.join(", ")}, Start Time (minutes in UTC): ${
+          w.startTime
+        }, End Time (minutes in UTC): ${w.endTime};`
+    )
+    .join("\n")}
+  ${
+    users.length
+      ? `The email references the following @usernames and emails: ${users
+          .map(
+            (u) =>
+              `${
+                (u.id ? `, id: ${u.id}` : "id: (non user)") +
+                (u.username
+                  ? u.type === "fromUsername"
+                    ? `, username: @${u.username}`
+                    : ", username: REDACTED"
+                  : ", (no username)") +
+                (u.email
+                  ? u.type === "fromEmail"
+                    ? `, email: ${u.email}`
+                    : ", email: REDACTED"
+                  : ", (no email)")
+              };`
+          )
+          .join("\n")}`
+      : ""
+  }`);
+  const agent = await createOpenAIFunctionsAgent({
+    llm: model,
+    prompt,
+    tools,
+  });
+
+  const executor = new AgentExecutor({
+    agent,
+    tools,
+    returnIntermediateSteps: env.NODE_ENV === "development",
+    verbose: env.NODE_ENV === "development",
+  });
+
+  const result = await executor.invoke({ input });
+  const { output } = result;
+
+  return output;
+};
+
+export default agent;

apps/ai/src/utils/context.ts

@@ -0,0 +1 @@
+export const context = { apiKey: "", userId: "" };

apps/ai/src/utils/extractUsers.ts

@@ -0,0 +1,85 @@
+import prisma from "@calcom/prisma";
+
+import type { UserList } from "../types/user";
+
+/*
+ * Extracts usernames (@Example) and emails (hi@example.com) from a string
+ */
+export const extractUsers = async (text: string) => {
+  const usernames = text
+    .match(/(?<![a-zA-Z0-9_.])@[a-zA-Z0-9_]+/g)
+    ?.map((username) => username.slice(1).toLowerCase());
+  const emails = text
+    .match(/[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+/g)
+    ?.map((email) => email.toLowerCase());
+
+  const dbUsersFromUsernames = usernames
+    ? await prisma.user.findMany({
+        select: {
+          id: true,
+          username: true,
+          email: true,
+        },
+        where: {
+          username: {
+            in: usernames,
+          },
+        },
+      })
+    : [];
+
+  const usersFromUsernames = usernames
+    ? usernames.map((username) => {
+        const user = dbUsersFromUsernames.find((u) => u.username === username);
+        return user
+          ? {
+              username,
+              id: user.id,
+              email: user.email,
+              type: "fromUsername",
+            }
+          : {
+              username,
+              id: null,
+              email: null,
+              type: "fromUsername",
+            };
+      })
+    : [];
+
+  const dbUsersFromEmails = emails
+    ? await prisma.user.findMany({
+        select: {
+          id: true,
+          email: true,
+          username: true,
+        },
+        where: {
+          email: {
+            in: emails,
+          },
+        },
+      })
+    : [];
+
+  const usersFromEmails = emails
+    ? emails.map((email) => {
+        const user = dbUsersFromEmails.find((u) => u.email === email);
+        return user
+          ? {
+              email,
+              id: user.id,
+              username: user.username,
+              type: "fromEmail",
+            }
+          : {
+              email,
+              id: null,
+              username: null,
+              type: "fromEmail",
+            };
+      })
+    : [];
+
+  return [...usersFromUsernames, ...usersFromEmails] as UserList;
+};

apps/ai/src/utils/host.ts

@@ -0,0 +1,7 @@
+import type { NextRequest } from "next/server";
+
+const getHostFromHeaders = (headers: NextRequest["headers"]): string => {
+  return `https://${headers.get("host")}`;
+};
+
+export default getHostFromHeaders;

apps/ai/src/utils/now.ts

@@ -0,0 +1,6 @@
+export default function now(timeZone: string, options: Intl.DateTimeFormatOptions = {}) {
+  return new Date().toLocaleString("en-US", {
+    timeZone,
+    ...options,
+  });
+}

apps/ai/src/utils/sendEmail.ts

@@ -0,0 +1,43 @@
+import mail from "@sendgrid/mail";
+
+const sendgridAPIKey = process.env.SENDGRID_API_KEY as string;
+
+/**
+ * Simply send an email by address, subject, and body.
+ */
+const send = async ({
+  subject,
+  to,
+  cc,
+  from,
+  text,
+  html,
+}: {
+  subject: string;
+  to: string | string[];
+  cc?: string | string[];
+  from: string;
+  text: string;
+  html?: string;
+}): Promise<boolean> => {
+  mail.setApiKey(sendgridAPIKey);
+
+  const msg = {
+    to,
+    cc,
+    from: {
+      email: from,
+      name: "Cal.ai",
+    },
+    text,
+    html,
+    subject,
+  };
+
+  const res = await mail.send(msg);
+  const success = !!res;
+
+  return success;
+};
+
+export default send;

apps/ai/src/utils/verifyParseKey.ts

@@ -0,0 +1,13 @@
+import type { NextRequest } from "next/server";
+
+import { env } from "../env.mjs";
+
+/**
+ * Verifies that the request contains the correct parse key.
+ * env.PARSE_KEY must be configured as a query param in the sendgrid inbound parse settings.
+ */
+export const verifyParseKey = (url: NextRequest["url"]) => {
+  const verified = new URL(url).searchParams.get("parseKey") === env.PARSE_KEY;
+
+  return verified;
+};

apps/ai/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "@calcom/tsconfig/nextjs.json",
+  "compilerOptions": {
+    "strict": true,
+    "jsx": "preserve",
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["*"]
+    },
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ]
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    "../../packages/types/window.d.ts"
+  ],
+  "exclude": ["node_modules"]
+}

apps/api/v1/pages/api/invites/_post.ts

@@ -43,7 +43,6 @@ async function postHandler(req: NextApiRequest, res: NextApiResponse) {
       language: data.language,
       teamId: data.teamId,
       usernameOrEmail: data.usernameOrEmail,
-      isOrg: data.isOrg,
     });
 
     return { success: true, message: `${data.usernameOrEmail} has been invited.` };

apps/api/v1/test/lib/attendees/_post.test.ts

@@ -0,0 +1,112 @@
+import prismaMock from "../../../../../../tests/libs/__mocks__/prismaMock";
+
+import type { Request, Response } from "express";
+import type { NextApiRequest, NextApiResponse } from "next";
+import { createMocks } from "node-mocks-http";
+import { describe, expect, test } from "vitest";
+
+import handler from "../../../pages/api/attendees/_post";
+
+type CustomNextApiRequest = NextApiRequest & Request;
+type CustomNextApiResponse = NextApiResponse & Response;
+
+describe("POST /api/attendees", () => {
+  describe("Errors", () => {
+    test("Returns 403 if user is not admin and has no booking", async () => {
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "POST",
+        body: {
+          bookingId: 1,
+          email: "test@example.com",
+          name: "Test User",
+          timeZone: "UTC",
+        },
+      });
+
+      prismaMock.booking.findFirst.mockResolvedValue(null);
+
+      req.userId = 123;
+      // req.isAdmin = false;
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(403);
+      expect(JSON.parse(res._getData()).message).toBe("Forbidden");
+    });
+
+    test("Returns 200 if user is admin", async () => {
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "POST",
+        body: {
+          bookingId: 1,
+          email: "test@example.com",
+          name: "Test User",
+          timeZone: "UTC",
+        },
+      });
+
+      const attendeeData = {
+        id: 1,
+        email: "test@example.com",
+        name: "Test User",
+        timeZone: "UTC",
+        bookingId: 1,
+      };
+
+      prismaMock.attendee.create.mockResolvedValue(attendeeData);
+      req.isSystemWideAdmin = true;
+      req.userId = 123;
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(200);
+      expect(JSON.parse(res._getData()).attendee).toEqual(attendeeData);
+      expect(JSON.parse(res._getData()).message).toBe("Attendee created successfully");
+    });
+
+    test("Returns 200 if user is not admin but has a booking", async () => {
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "POST",
+        body: {
+          bookingId: 1,
+          email: "test@example.com",
+          name: "Test User",
+          timeZone: "UTC",
+        },
+      });
+
+      const userBooking = { id: 1 };
+
+      prismaMock.booking.findFirst.mockResolvedValue(userBooking);
+
+      const attendeeData = {
+        id: 1,
+        email: "test@example.com",
+        name: "Test User",
+        timeZone: "UTC",
+        bookingId: 1,
+      };
+
+      prismaMock.attendee.create.mockResolvedValue(attendeeData);
+
+      req.userId = 123;
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(200);
+      expect(JSON.parse(res._getData()).attendee).toEqual(attendeeData);
+      expect(JSON.parse(res._getData()).message).toBe("Attendee created successfully");
+    });
+
+    test("Returns 400 if request body is invalid", async () => {
+      const { req, res } = createMocks<CustomNextApiRequest, CustomNextApiResponse>({
+        method: "POST",
+        body: {
+          // Missing required fields
+        },
+      });
+
+      req.userId = 123;
+      await handler(req, res);
+
+      expect(res.statusCode).toBe(400);
+    });
+  });
+});

apps/api/v2/package.json

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

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.20";
 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.20";
 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.20";
 
 export class CreateRecurringBookingInput extends CreateBookingInput {
   @IsBoolean()

apps/api/v2/src/ee/calendars/calendars.module.ts

@@ -1,3 +1,4 @@
+import { CalendarsRepository } from "@/ee/calendars/calendars.repository";
 import { CalendarsController } from "@/ee/calendars/controllers/calendars.controller";
 import { AppleCalendarService } from "@/ee/calendars/services/apple-calendar.service";
 import { CalendarsService } from "@/ee/calendars/services/calendars.service";
@@ -21,6 +22,7 @@ import { Module } from "@nestjs/common";
     AppleCalendarService,
     SelectedCalendarsRepository,
     AppsRepository,
+    CalendarsRepository,
   ],
   controllers: [CalendarsController],
   exports: [CalendarsService],

apps/api/v2/src/ee/calendars/calendars.repository.ts

@@ -0,0 +1,51 @@
+import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { Injectable } from "@nestjs/common";
+import { Prisma } from "@prisma/client";
+
+const credentialForCalendarRepositorySelect = Prisma.validator<Prisma.CredentialSelect>()({
+  id: true,
+  appId: true,
+  type: true,
+  userId: true,
+  user: {
+    select: {
+      email: true,
+    },
+  },
+  teamId: true,
+  key: true,
+  invalid: true,
+});
+
+@Injectable()
+export class CalendarsRepository {
+  constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
+
+  async getCalendarCredentials(credentialId: number, userId: number) {
+    return await this.dbRead.prisma.credential.findFirst({
+      where: {
+        id: credentialId,
+        userId,
+      },
+      select: {
+        ...credentialForCalendarRepositorySelect,
+        app: {
+          select: {
+            slug: true,
+            categories: true,
+            dirName: true,
+          },
+        },
+      },
+    });
+  }
+
+  async deleteCredentials(credentialId: number) {
+    return await this.dbWrite.prisma.credential.delete({
+      where: {
+        id: credentialId,
+      },
+    });
+  }
+}

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

@@ -1,5 +1,6 @@
 import { bootstrap } from "@/app";
 import { AppModule } from "@/app.module";
+import { DeletedCalendarCredentialsOutputResponseDto } from "@/ee/calendars/outputs/delete-calendar-credentials.output";
 import { CalendarsService } from "@/ee/calendars/services/calendars.service";
 import { HttpExceptionFilter } from "@/filters/http-exception.filter";
 import { PrismaExceptionFilter } from "@/filters/prisma-exception.filter";
@@ -18,6 +19,7 @@ import { TokensRepositoryFixture } from "test/fixtures/repository/tokens.reposit
 import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
 import { CalendarsServiceMock } from "test/mocks/calendars-service-mock";
 
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
 import {
   GOOGLE_CALENDAR,
   OFFICE_365_CALENDAR,
@@ -189,6 +191,26 @@ describe("Platform Calendars Endpoints", () => {
       .expect(200);
   });
 
+  it.skip(`/POST/v2/calendars/${OFFICE_365_CALENDAR}/disconnect: it should respond with a 201 returning back the user deleted calendar credentials`, async () => {
+    const body = {
+      id: 10,
+    };
+
+    return request(app.getHttpServer())
+      .post(`/v2/calendars/${OFFICE_365_CALENDAR}/disconnect`)
+      .set("Authorization", `Bearer ${accessTokenSecret}`)
+      .send(body)
+      .expect(201)
+      .then(async (response) => {
+        const responseBody: Promise<DeletedCalendarCredentialsOutputResponseDto> = response.body;
+
+        expect((await responseBody).status).toEqual(SUCCESS_STATUS);
+        expect((await responseBody).data).toBeDefined();
+        expect((await responseBody).data.id).toEqual(body.id);
+        expect((await responseBody).data.userId).toEqual(user.id);
+      });
+  });
+
   afterAll(async () => {
     await oauthClientRepositoryFixture.delete(oAuthClient.id);
     await teamRepositoryFixture.delete(organization.id);

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

@@ -1,5 +1,10 @@
+import { CalendarsRepository } from "@/ee/calendars/calendars.repository";
 import { GetBusyTimesOutput } from "@/ee/calendars/outputs/busy-times.output";
 import { ConnectedCalendarsOutput } from "@/ee/calendars/outputs/connected-calendars.output";
+import {
+  DeletedCalendarCredentialsOutputResponseDto,
+  DeletedCalendarCredentialsOutputDto,
+} from "@/ee/calendars/outputs/delete-calendar-credentials.output";
 import { AppleCalendarService } from "@/ee/calendars/services/apple-calendar.service";
 import { CalendarsService } from "@/ee/calendars/services/calendars.service";
 import { GoogleCalendarService } from "@/ee/calendars/services/gcal.service";
@@ -27,6 +32,7 @@ import {
 } from "@nestjs/common";
 import { ApiTags as DocsTags } from "@nestjs/swagger";
 import { User } from "@prisma/client";
+import { plainToClass } from "class-transformer";
 import { Request } from "express";
 import { z } from "zod";
 
@@ -50,7 +56,8 @@ export class CalendarsController {
     private readonly calendarsService: CalendarsService,
     private readonly outlookService: OutlookService,
     private readonly googleCalendarService: GoogleCalendarService,
-    private readonly appleCalendarService: AppleCalendarService
+    private readonly appleCalendarService: AppleCalendarService,
+    private readonly calendarsRepository: CalendarsRepository
   ) {}
 
   @UseGuards(ApiAuthGuard)
@@ -183,4 +190,29 @@ export class CalendarsController {
         );
     }
   }
+
+  @UseGuards(ApiAuthGuard)
+  @Post("/:calendar/disconnect")
+  @HttpCode(HttpStatus.OK)
+  async deleteCalendarCredentials(
+    @Param("calendar") calendar: string,
+    @Body() body: { id: number },
+    @GetUser() user: UserWithProfile
+  ): Promise<DeletedCalendarCredentialsOutputResponseDto> {
+    const { id: credentialId } = body;
+    await this.calendarsService.checkCalendarCredentials(credentialId, user.id);
+
+    const { id, type, userId, teamId, appId, invalid } = await this.calendarsRepository.deleteCredentials(
+      credentialId
+    );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: plainToClass(
+        DeletedCalendarCredentialsOutputDto,
+        { id, type, userId, teamId, appId, invalid },
+        { strategy: "excludeAll" }
+      ),
+    };
+  }
 }

apps/api/v2/src/ee/calendars/outputs/delete-calendar-credentials.output.ts

@@ -0,0 +1,42 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { Expose, Type } from "class-transformer";
+import { IsString, ValidateNested, IsEnum, IsInt, IsBoolean } from "class-validator";
+
+import { ERROR_STATUS, SUCCESS_STATUS } from "@calcom/platform-constants";
+
+export class DeletedCalendarCredentialsOutputDto {
+  @IsInt()
+  @Expose()
+  readonly id!: number;
+
+  @IsString()
+  @Expose()
+  readonly type!: string;
+
+  @IsInt()
+  @Expose()
+  readonly userId!: number | null;
+
+  @IsInt()
+  @Expose()
+  readonly teamId!: number | null;
+
+  @IsString()
+  @Expose()
+  readonly appId!: string | null;
+
+  @IsBoolean()
+  @Expose()
+  readonly invalid!: boolean | null;
+}
+
+export class DeletedCalendarCredentialsOutputResponseDto {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @Expose()
+  @ValidateNested()
+  @Type(() => DeletedCalendarCredentialsOutputDto)
+  data!: DeletedCalendarCredentialsOutputDto;
+}

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.20";
 
 @Injectable()
 export class AppleCalendarService implements CredentialSyncCalendarApp {

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

@@ -1,3 +1,4 @@
+import { CalendarsRepository } from "@/ee/calendars/calendars.repository";
 import { AppsRepository } from "@/modules/apps/apps.repository";
 import {
   CredentialsRepository,
@@ -17,7 +18,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.20";
 import { Calendar } from "@calcom/platform-types";
 import { PrismaClient } from "@calcom/prisma";
 
@@ -29,6 +30,7 @@ export class CalendarsService {
     private readonly usersRepository: UsersRepository,
     private readonly credentialsRepository: CredentialsRepository,
     private readonly appsRepository: AppsRepository,
+    private readonly calendarsRepository: CalendarsRepository,
     private readonly dbRead: PrismaReadService,
     private readonly dbWrite: PrismaWriteService,
     private readonly config: ConfigService
@@ -136,4 +138,11 @@ export class CalendarsService {
 
     return { client_id, client_secret };
   }
+
+  async checkCalendarCredentials(credentialId: number, userId: number) {
+    const credential = await this.calendarsRepository.getCalendarCredentials(credentialId, userId);
+    if (!credential) {
+      throw new NotFoundException("Calendar credentials not found");
+    }
+  }
 }

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.20";
 import { ApiSuccessResponse } from "@calcom/platform-types";
 
 describe("Event types Endpoints", () => {

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

@@ -39,7 +39,8 @@ import {
 import { ApiTags as DocsTags } from "@nestjs/swagger";
 
 import { EVENT_TYPE_READ, EVENT_TYPE_WRITE, SUCCESS_STATUS } from "@calcom/platform-constants";
-import { getPublicEvent, getEventTypesByViewer } from "@calcom/platform-libraries-0.0.18";
+import { getPublicEvent, getEventTypesByViewer } from "@calcom/platform-libraries-0.0.2";
+
 import { PrismaClient } from "@calcom/prisma";
 
 @Controller({

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.20";
 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.20";
 import { EventType } from "@calcom/prisma/client";
 
 @Injectable()

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

@@ -9,10 +9,11 @@ import { UsersModule } from "@/modules/users/users.module";
 import { INestApplication } from "@nestjs/common";
 import { NestExpressApplication } from "@nestjs/platform-express";
 import { Test } from "@nestjs/testing";
-import { PlatformOAuthClient, Team, User } from "@prisma/client";
+import { PlatformOAuthClient, Team, User, Schedule } from "@prisma/client";
 import * as request from "supertest";
 import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
 import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
+import { SchedulesRepositoryFixture } from "test/fixtures/repository/schedules.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";
@@ -63,12 +64,18 @@ describe("Event types Endpoints", () => {
     let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
     let teamRepositoryFixture: TeamRepositoryFixture;
     let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
+    let schedulesRepostoryFixture: SchedulesRepositoryFixture;
 
     const userEmail = "event-types-test-e2e@api.com";
+    const falseTestEmail = "false-event-types@api.com";
     const name = "bob-the-builder";
     const username = name;
     let eventType: EventTypeOutput_2024_06_14;
     let user: User;
+    let falseTestUser: User;
+    let firstSchedule: Schedule;
+    let secondSchedule: Schedule;
+    let falseTestSchedule: Schedule;
 
     beforeAll(async () => {
       const moduleRef = await withApiAuth(
@@ -91,6 +98,7 @@ describe("Event types Endpoints", () => {
       userRepositoryFixture = new UserRepositoryFixture(moduleRef);
       teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
       eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
+      schedulesRepostoryFixture = new SchedulesRepositoryFixture(moduleRef);
 
       organization = await teamRepositoryFixture.create({ name: "organization" });
       oAuthClient = await createOAuthClient(organization.id);
@@ -100,6 +108,30 @@ describe("Event types Endpoints", () => {
         username,
       });
 
+      falseTestUser = await userRepositoryFixture.create({
+        email: falseTestEmail,
+        name: "false-test",
+        username: falseTestEmail,
+      });
+
+      firstSchedule = await schedulesRepostoryFixture.create({
+        userId: user.id,
+        name: "work",
+        timeZone: "Europe/Rome",
+      });
+
+      secondSchedule = await schedulesRepostoryFixture.create({
+        userId: user.id,
+        name: "chill",
+        timeZone: "Europe/Rome",
+      });
+
+      falseTestSchedule = await schedulesRepostoryFixture.create({
+        userId: falseTestUser.id,
+        name: "work",
+        timeZone: "Europe/Rome",
+      });
+
       await app.init();
     });
 
@@ -123,6 +155,40 @@ describe("Event types Endpoints", () => {
       expect(user).toBeDefined();
     });
 
+    it("should not allow creating an event type with schedule user does not own", async () => {
+      const scheduleId = falseTestSchedule.id;
+
+      const body: CreateEventTypeInput_2024_06_14 = {
+        title: "Coding class",
+        slug: "coding-class",
+        description: "Let's learn how to code like a pro.",
+        lengthInMinutes: 60,
+        locations: [
+          {
+            type: "integration",
+            integration: "cal-video",
+          },
+        ],
+        bookingFields: [
+          {
+            type: "select",
+            label: "select which language you want to learn",
+            slug: "select-language",
+            required: true,
+            placeholder: "select language",
+            options: ["javascript", "python", "cobol"],
+          },
+        ],
+        scheduleId,
+      };
+
+      return request(app.getHttpServer())
+        .post("/api/v2/event-types")
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send(body)
+        .expect(404);
+    });
+
     it("should create an event type", async () => {
       const body: CreateEventTypeInput_2024_06_14 = {
         title: "Coding class",
@@ -145,6 +211,7 @@ describe("Event types Endpoints", () => {
             options: ["javascript", "python", "cobol"],
           },
         ],
+        scheduleId: firstSchedule.id,
       };
 
       return request(app.getHttpServer())
@@ -162,6 +229,7 @@ describe("Event types Endpoints", () => {
           expect(createdEventType.locations).toEqual(body.locations);
           expect(createdEventType.bookingFields).toEqual(body.bookingFields);
           expect(createdEventType.ownerId).toEqual(user.id);
+          expect(createdEventType.scheduleId).toEqual(firstSchedule.id);
 
           eventType = responseBody.data;
         });
@@ -172,6 +240,7 @@ describe("Event types Endpoints", () => {
 
       const body: UpdateEventTypeInput_2024_06_14 = {
         title: newTitle,
+        scheduleId: secondSchedule.id,
       };
 
       return request(app.getHttpServer())
@@ -191,11 +260,25 @@ describe("Event types Endpoints", () => {
           expect(updatedEventType.locations).toEqual(eventType.locations);
           expect(updatedEventType.bookingFields).toEqual(eventType.bookingFields);
           expect(updatedEventType.ownerId).toEqual(user.id);
+          expect(updatedEventType.scheduleId).toEqual(secondSchedule.id);
 
           eventType.title = newTitle;
+          eventType.scheduleId = secondSchedule.id;
         });
     });
 
+    it("should not allow to update event type with scheduleId user does not own", async () => {
+      const body: UpdateEventTypeInput_2024_06_14 = {
+        scheduleId: falseTestSchedule.id,
+      };
+
+      return request(app.getHttpServer())
+        .patch(`/api/v2/event-types/${eventType.id}`)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+        .send(body)
+        .expect(404);
+    });
+
     it(`/GET/:id`, async () => {
       const response = await request(app.getHttpServer())
         .get(`/api/v2/event-types/${eventType.id}`)
@@ -272,7 +355,7 @@ describe("Event types Endpoints", () => {
         .expect(404);
     });
 
-    it("should delete schedule", async () => {
+    it("should delete event type", async () => {
       return request(app.getHttpServer()).delete(`/api/v2/event-types/${eventType.id}`).expect(200);
     });
 
@@ -289,6 +372,11 @@ describe("Event types Endpoints", () => {
       } catch (e) {
         // User might have been deleted by the test
       }
+      try {
+        await userRepositoryFixture.delete(falseTestUser.id);
+      } catch (e) {
+        // User might have been deleted by the test
+      }
       await app.close();
     });
   });

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

@@ -3,6 +3,7 @@ import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_20
 import { EventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/event-types.service";
 import { InputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/input-event-types.service";
 import { OutputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/output-event-types.service";
+import { SchedulesRepository_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.repository";
 import { MembershipsModule } from "@/modules/memberships/memberships.module";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
 import { SelectedCalendarsModule } from "@/modules/selected-calendars/selected-calendars.module";
@@ -20,8 +21,14 @@ import { Module } from "@nestjs/common";
     OutputEventTypesService_2024_06_14,
     UsersRepository,
     UsersService,
+    SchedulesRepository_2024_06_11,
   ],
   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.20";
 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

@@ -2,6 +2,7 @@ import { DEFAULT_EVENT_TYPES } from "@/ee/event-types/event-types_2024_06_14/con
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
 import { InputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/input-event-types.service";
 import { OutputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/output-event-types.service";
+import { SchedulesRepository_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.repository";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { SelectedCalendarsRepository } from "@/modules/selected-calendars/selected-calendars.repository";
@@ -9,9 +10,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 { createEventType, updateEventType } from "@calcom/platform-libraries-0.0.20";
-import { getEventTypesPublic, EventTypesPublic } from "@calcom/platform-libraries-0.0.18";
+import { getEventTypesPublic, EventTypesPublic } from "@calcom/platform-libraries-0.0.20";
-import { dynamicEvent } from "@calcom/platform-libraries-0.0.18";
+import { dynamicEvent } from "@calcom/platform-libraries-0.0.20";
 import {
   CreateEventTypeInput_2024_06_14,
   UpdateEventTypeInput_2024_06_14,
@@ -30,7 +31,8 @@ export class EventTypesService_2024_06_14 {
     private readonly usersRepository: UsersRepository,
     private readonly usersService: UsersService,
     private readonly selectedCalendarsRepository: SelectedCalendarsRepository,
-    private readonly dbWrite: PrismaWriteService
+    private readonly dbWrite: PrismaWriteService,
+    private readonly schedulesRepository: SchedulesRepository_2024_06_11
   ) {}
 
   async createUserEventType(user: UserWithProfile, body: CreateEventTypeInput_2024_06_14) {
@@ -61,6 +63,7 @@ export class EventTypesService_2024_06_14 {
     if (existsWithSlug) {
       throw new BadRequestException("User already has an event type with this slug.");
     }
+    await this.checkUserOwnsSchedule(userId, body.scheduleId);
   }
 
   async getEventTypeByUsernameAndSlug(username: string, eventTypeSlug: string) {
@@ -203,7 +206,7 @@ export class EventTypesService_2024_06_14 {
   }
 
   async updateEventType(eventTypeId: number, body: UpdateEventTypeInput_2024_06_14, user: UserWithProfile) {
-    this.checkCanUpdateEventType(user.id, eventTypeId);
+    await this.checkCanUpdateEventType(user.id, eventTypeId, body.scheduleId);
     const eventTypeUser = await this.getUserToUpdateEvent(user);
     const bodyTransformed = this.inputEventTypesService.transformInputUpdateEventType(body);
     await updateEventType({
@@ -225,12 +228,13 @@ export class EventTypesService_2024_06_14 {
     return this.outputEventTypesService.getResponseEventType(user.id, eventType);
   }
 
-  async checkCanUpdateEventType(userId: number, eventTypeId: number) {
+  async checkCanUpdateEventType(userId: number, eventTypeId: number, scheduleId: number | undefined) {
     const existingEventType = await this.getUserEventType(userId, eventTypeId);
     if (!existingEventType) {
       throw new NotFoundException(`Event type with id ${eventTypeId} not found`);
     }
     this.checkUserOwnsEventType(userId, { id: eventTypeId, userId: existingEventType.ownerId });
+    await this.checkUserOwnsSchedule(userId, scheduleId);
   }
 
   async getUserToUpdateEvent(user: UserWithProfile) {
@@ -255,4 +259,16 @@ export class EventTypesService_2024_06_14 {
       throw new ForbiddenException(`User with ID=${userId} does not own event type with ID=${eventType.id}`);
     }
   }
+
+  async checkUserOwnsSchedule(userId: number, scheduleId: number | null | undefined) {
+    if (!scheduleId) {
+      return;
+    }
+
+    const schedule = await this.schedulesRepository.getScheduleByIdAndUserId(scheduleId, userId);
+
+    if (!schedule) {
+      throw new NotFoundException(`User with ID=${userId} does not own schedule with ID=${scheduleId}`);
+    }
+  }
 }

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.20";
 import { CreateEventTypeInput_2024_06_14, UpdateEventTypeInput_2024_06_14 } from "@calcom/platform-types";
 
 @Injectable()
@@ -29,12 +29,14 @@ export class InputEventTypesService_2024_06_14 {
   }
 
   transformInputUpdateEventType(inputEventType: UpdateEventTypeInput_2024_06_14) {
-    const { locations, bookingFields, ...rest } = inputEventType;
+    const { lengthInMinutes, locations, bookingFields, scheduleId, ...rest } = inputEventType;
 
     const eventType = {
       ...rest,
+      length: lengthInMinutes,
       locations: locations ? this.transformInputLocations(locations) : undefined,
       bookingFields: bookingFields ? this.transformInputBookingFields(bookingFields) : undefined,
+      schedule: scheduleId,
     };
 
     return eventType;

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.20";
 
 type EventTypeRelations = { users: User[]; schedule: Schedule | null };
 type DatabaseEventType = EventType & EventTypeRelations;
@@ -41,7 +41,7 @@ type Input = Pick<
   | "recurringEvent"
   | "metadata"
   | "users"
-  | "schedule"
+  | "scheduleId"
 >;
 
 @Injectable()
@@ -68,13 +68,13 @@ export class OutputEventTypesService_2024_06_14 {
       successRedirectUrl,
       seatsShowAvailabilityCount,
       isInstantEvent,
+      scheduleId,
     } = databaseEventType;
 
     const locations = this.transformLocations(databaseEventType.locations);
     const bookingFields = this.transformBookingFields(databaseEventType.bookingFields);
     const recurringEvent = this.transformRecurringEvent(databaseEventType.recurringEvent);
     const metadata = this.transformMetadata(databaseEventType.metadata) || {};
-    const schedule = await this.getSchedule(databaseEventType);
     const users = this.transformUsers(databaseEventType.users);
 
     return {
@@ -104,7 +104,7 @@ export class OutputEventTypesService_2024_06_14 {
       seatsShowAvailabilityCount,
       isInstantEvent,
       users,
-      schedule,
+      scheduleId,
     };
   }
 
@@ -128,10 +128,6 @@ export class OutputEventTypesService_2024_06_14 {
     return EventTypeMetaDataSchema.parse(metadata);
   }
 
-  async getSchedule(databaseEventType: Input) {
-    return databaseEventType.schedule || null;
-  }
-
   transformUsers(users: User[]) {
     return users.map((user) => {
       const metadata = user.metadata ? userMetadata.parse(user.metadata) : {};

apps/api/v2/src/ee/gcal/gcal.module.ts

@@ -1,3 +1,4 @@
+import { CalendarsRepository } from "@/ee/calendars/calendars.repository";
 import { CalendarsService } from "@/ee/calendars/services/calendars.service";
 import { GcalController } from "@/ee/gcal/gcal.controller";
 import { AppsRepository } from "@/modules/apps/apps.repository";
@@ -21,6 +22,7 @@ import { ConfigService } from "@nestjs/config";
     GCalService,
     CalendarsService,
     UsersRepository,
+    CalendarsRepository,
   ],
   controllers: [GcalController],
 })

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

@@ -103,6 +103,21 @@ describe("Me Endpoints", () => {
         });
     });
 
+    it("should update user associated with access token given badly formatted timezone", async () => {
+      const bodyWithBadlyFormattedTimeZone: UpdateManagedUserInput = { timeZone: "America/New_york" };
+
+      return request(app.getHttpServer())
+        .patch("/v2/me")
+        .send(bodyWithBadlyFormattedTimeZone)
+        .expect(200)
+        .then(async (response) => {
+          const responseBody: ApiSuccessResponse<UserResponse> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+
+          expect(responseBody.data.timeZone).toEqual("America/New_York");
+        });
+    });
+
     it("should not update user associated with access token given invalid timezone", async () => {
       const bodyWithIncorrectTimeZone: UpdateManagedUserInput = { timeZone: "Narnia/Woods" };
 

apps/api/v2/src/ee/me/me.controller.ts

@@ -23,7 +23,7 @@ import { userSchemaResponse } from "@calcom/platform-types";
 export class MeController {
   constructor(
     private readonly usersRepository: UsersRepository,
-    private readonly schedulesRepository: SchedulesService_2024_04_15
+    private readonly schedulesService: SchedulesService_2024_04_15
   ) {}
 
   @Get("/")
@@ -45,7 +45,7 @@ export class MeController {
   ): Promise<UpdateMeOutput> {
     const updatedUser = await this.usersRepository.update(user.id, bodySchedule);
     if (bodySchedule.timeZone && user.defaultScheduleId) {
-      await this.schedulesRepository.updateUserSchedule(user, user.defaultScheduleId, {
+      await this.schedulesService.updateUserSchedule(user, user.defaultScheduleId, {
         timeZone: bodySchedule.timeZone,
       });
     }

apps/api/v2/src/ee/schedules/schedules_2024_06_11/schedules.repository.ts

@@ -96,6 +96,17 @@ export class SchedulesRepository_2024_06_11 {
     return schedule;
   }
 
+  async getScheduleByIdAndUserId(scheduleId: number, userId: number) {
+    const schedule = await this.dbRead.prisma.schedule.findUnique({
+      where: {
+        id: scheduleId,
+        userId,
+      },
+    });
+
+    return schedule;
+  }
+
   async updateSchedule(
     userId: number,
     scheduleId: number,

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.20";
 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.20";
 import { Response } from "@calcom/platform-types";
 
 @Catch(TRPCError)

apps/api/v2/src/modules/auth/strategies/api-auth/api-auth.strategy.e2e-spec.ts

@@ -37,9 +37,9 @@ describe("ApiAuthStrategy", () => {
   const validAccessTokenEmail = "access-token-user-email@example.com";
   let validApiKeyUser: User;
   let validAccessTokenUser: User;
-
+  let module: TestingModule;
-  beforeEach(async () => {
+  beforeAll(async () => {
-    const module: TestingModule = await Test.createTestingModule({
+    module = await Test.createTestingModule({
       imports: [
         ConfigModule.forRoot({
           ignoreEnvFile: true,
@@ -177,4 +177,10 @@ describe("ApiAuthStrategy", () => {
       }
     });
   });
+
+  afterAll(async () => {
+    await userRepositoryFixture.deleteByEmail(validApiKeyEmail);
+    await userRepositoryFixture.deleteByEmail(validAccessTokenEmail);
+    module.close();
+  });
 });

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.20";
 
 @Injectable()
 export class EmailService {

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

@@ -50,12 +50,13 @@ export class MembershipsRepository {
     return !!adminMembership;
   }
 
-  async createMembership(teamId: number, userId: number, role: MembershipRole) {
+  async createMembership(teamId: number, userId: number, role: MembershipRole, accepted: boolean) {
     const membership = await this.dbRead.prisma.membership.create({
       data: {
         role,
         teamId,
         userId,
+        accepted,
       },
     });
 

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.20";
 
 @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,596 @@
+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 userRepositoryFixture.deleteByEmail(falseTestUser.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/controllers/memberships/organizations-membership.controller.e2e-spec.ts

@@ -1,6 +1,7 @@
 import { bootstrap } from "@/app";
 import { AppModule } from "@/app.module";
 import { CreateOrgMembershipDto } from "@/modules/organizations/inputs/create-organization-membership.input";
+import { UpdateOrgMembershipDto } from "@/modules/organizations/inputs/update-organization-membership.input";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
 import { TokensModule } from "@/modules/tokens/tokens.module";
 import { UsersModule } from "@/modules/users/users.module";
@@ -18,8 +19,6 @@ import { SUCCESS_STATUS } from "@calcom/platform-constants";
 import { ApiSuccessResponse } from "@calcom/platform-types";
 import { Membership, Team } from "@calcom/prisma/client";
 
-import { UpdateOrgMembershipDto } from "../../inputs/update-organization-membership.input";
-
 describe("Organizations Memberships Endpoints", () => {
   describe("User Authentication - User is Org Admin", () => {
     let app: INestApplication;
@@ -198,6 +197,7 @@ describe("Organizations Memberships Endpoints", () => {
 
     afterAll(async () => {
       await userRepositoryFixture.deleteByEmail(user.email);
+      await userRepositoryFixture.deleteByEmail(user2.email);
       await userRepositoryFixture.deleteByEmail(userToInviteViaApi.email);
       await organizationsRepositoryFixture.delete(org.id);
       await app.close();

apps/api/v2/src/modules/organizations/controllers/teams/memberships/organizations-teams-memberships.controller.e2e-spec.ts

@@ -0,0 +1,342 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { CreateOrgTeamMembershipDto } from "@/modules/organizations/inputs/create-organization-team-membership.input";
+import { UpdateOrgTeamMembershipDto } from "@/modules/organizations/inputs/update-organization-team-membership.input";
+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 { 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 } from "@calcom/platform-types";
+import { Membership, Team } from "@calcom/prisma/client";
+
+describe("Organizations Teams Memberships Endpoints", () => {
+  describe("User Authentication - User is Org Admin", () => {
+    let app: INestApplication;
+
+    let userRepositoryFixture: UserRepositoryFixture;
+    let organizationsRepositoryFixture: TeamRepositoryFixture;
+    let teamsRepositoryFixture: TeamRepositoryFixture;
+    let profileRepositoryFixture: ProfileRepositoryFixture;
+
+    let membershipsRepositoryFixture: MembershipRepositoryFixture;
+
+    let org: Team;
+    let orgTeam: Team;
+    let nonOrgTeam: Team;
+    let membership: Membership;
+    let membership2: Membership;
+    let membershipCreatedViaApi: Membership;
+
+    const userEmail = "org-admin-membership-teams-controller-e2e@api.com";
+    const userEmail2 = "org-member-membership-teams-controller-e2e@api.com";
+    const nonOrgUserEmail = "non-org-member-membership-teams-controller-e2e@api.com";
+
+    const invitedUserEmail = "org-member-invited-membership-teams-controller-e2e@api.com";
+
+    let user: User;
+    let user2: User;
+    let nonOrgUser: User;
+
+    let userToInviteViaApi: User;
+
+    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);
+      profileRepositoryFixture = new ProfileRepositoryFixture(moduleRef);
+
+      membershipsRepositoryFixture = new MembershipRepositoryFixture(moduleRef);
+
+      user = await userRepositoryFixture.create({
+        email: userEmail,
+        username: userEmail,
+      });
+      user2 = await userRepositoryFixture.create({
+        email: userEmail2,
+        username: userEmail2,
+      });
+
+      nonOrgUser = await userRepositoryFixture.create({
+        email: nonOrgUserEmail,
+        username: nonOrgUserEmail,
+      });
+
+      userToInviteViaApi = await userRepositoryFixture.create({
+        email: invitedUserEmail,
+        username: invitedUserEmail,
+      });
+
+      org = await organizationsRepositoryFixture.create({
+        name: "Test Organization",
+        isOrganization: true,
+      });
+
+      orgTeam = await teamsRepositoryFixture.create({
+        name: "Org Team",
+        isOrganization: false,
+        parent: { connect: { id: org.id } },
+      });
+
+      nonOrgTeam = await teamsRepositoryFixture.create({
+        name: "Non Org Team",
+        isOrganization: false,
+      });
+
+      membership = await membershipsRepositoryFixture.create({
+        role: "ADMIN",
+        user: { connect: { id: user.id } },
+        team: { connect: { id: orgTeam.id } },
+      });
+
+      membership2 = await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: user2.id } },
+        team: { connect: { id: orgTeam.id } },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "ADMIN",
+        user: { connect: { id: user.id } },
+        team: { connect: { id: org.id } },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: user2.id } },
+        team: { connect: { id: org.id } },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: userToInviteViaApi.id } },
+        team: { connect: { id: org.id } },
+      });
+
+      await membershipsRepositoryFixture.create({
+        role: "MEMBER",
+        user: { connect: { id: nonOrgUser.id } },
+        team: { connect: { id: nonOrgTeam.id } },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${user.id}`,
+        username: userEmail,
+        organization: {
+          connect: {
+            id: org.id,
+          },
+        },
+        user: {
+          connect: {
+            id: user.id,
+          },
+        },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${user2.id}`,
+        username: userEmail2,
+        organization: {
+          connect: {
+            id: org.id,
+          },
+        },
+        user: {
+          connect: {
+            id: user2.id,
+          },
+        },
+      });
+
+      await profileRepositoryFixture.create({
+        uid: `usr-${userToInviteViaApi.id}`,
+        username: invitedUserEmail,
+        organization: {
+          connect: {
+            id: org.id,
+          },
+        },
+        user: {
+          connect: {
+            id: userToInviteViaApi.id,
+          },
+        },
+      });
+
+      app = moduleRef.createNestApplication();
+      bootstrap(app as NestExpressApplication);
+
+      await app.init();
+    });
+
+    it("should be defined", () => {
+      expect(userRepositoryFixture).toBeDefined();
+      expect(organizationsRepositoryFixture).toBeDefined();
+      expect(user).toBeDefined();
+      expect(org).toBeDefined();
+    });
+
+    it("should get all the memberships of the org's team", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships`)
+        .expect(200)
+        .then((response) => {
+          const responseBody: ApiSuccessResponse<Membership[]> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data[0].id).toEqual(membership.id);
+          expect(responseBody.data[1].id).toEqual(membership2.id);
+          expect(responseBody.data.length).toEqual(2);
+        });
+    });
+
+    it("should fail to get all the memberships of team which is not in the org", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${nonOrgTeam.id}/memberships`)
+        .expect(404);
+    });
+
+    it("should get all the memberships of the org's team paginated", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships?skip=1&take=1`)
+        .expect(200)
+        .then((response) => {
+          const responseBody: ApiSuccessResponse<Membership[]> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data[0].id).toEqual(membership2.id);
+          expect(responseBody.data[0].userId).toEqual(user2.id);
+          expect(responseBody.data.length).toEqual(1);
+        });
+    });
+
+    it("should fail if org does not exist", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/120494059/teams/${orgTeam.id}/memberships`)
+        .expect(403);
+    });
+
+    it("should get the membership of the org's team", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships/${membership.id}`)
+        .expect(200)
+        .then((response) => {
+          const responseBody: ApiSuccessResponse<Membership> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data.id).toEqual(membership.id);
+          expect(responseBody.data.userId).toEqual(user.id);
+        });
+    });
+
+    it("should fail to get the membership of a team not in the org", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${nonOrgTeam.id}/memberships/${membership.id}`)
+        .expect(404);
+    });
+
+    it("should fail to create the membership of a team not in the org", async () => {
+      return request(app.getHttpServer())
+        .post(`/v2/organizations/${org.id}/teams/${nonOrgTeam.id}/memberships`)
+        .send({
+          userId: userToInviteViaApi.id,
+          accepted: true,
+          role: "MEMBER",
+        } satisfies CreateOrgTeamMembershipDto)
+        .expect(404);
+    });
+
+    it("should create the membership of the org's team", async () => {
+      return request(app.getHttpServer())
+        .post(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships`)
+        .send({
+          userId: userToInviteViaApi.id,
+          accepted: true,
+          role: "MEMBER",
+        } satisfies CreateOrgTeamMembershipDto)
+        .expect(201)
+        .then((response) => {
+          const responseBody: ApiSuccessResponse<Membership> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          membershipCreatedViaApi = responseBody.data;
+          expect(membershipCreatedViaApi.teamId).toEqual(orgTeam.id);
+          expect(membershipCreatedViaApi.role).toEqual("MEMBER");
+          expect(membershipCreatedViaApi.userId).toEqual(userToInviteViaApi.id);
+        });
+    });
+
+    it("should fail to create the membership of the org's team for a non org user", async () => {
+      return request(app.getHttpServer())
+        .post(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships`)
+        .send({
+          userId: nonOrgUser.id,
+          accepted: true,
+          role: "MEMBER",
+        } satisfies CreateOrgTeamMembershipDto)
+        .expect(422);
+    });
+
+    it("should update the membership of the org's team", async () => {
+      return request(app.getHttpServer())
+        .patch(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships/${membershipCreatedViaApi.id}`)
+        .send({
+          role: "OWNER",
+        } satisfies UpdateOrgTeamMembershipDto)
+        .expect(200)
+        .then((response) => {
+          const responseBody: ApiSuccessResponse<Membership> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          membershipCreatedViaApi = responseBody.data;
+          expect(membershipCreatedViaApi.role).toEqual("OWNER");
+        });
+    });
+
+    it("should delete the membership of the org's team we created via api", async () => {
+      return request(app.getHttpServer())
+        .delete(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships/${membershipCreatedViaApi.id}`)
+        .expect(200)
+        .then((response) => {
+          const responseBody: ApiSuccessResponse<Membership> = response.body;
+          expect(responseBody.status).toEqual(SUCCESS_STATUS);
+          expect(responseBody.data.id).toEqual(membershipCreatedViaApi.id);
+        });
+    });
+
+    it("should fail to get the membership of the org's team we just deleted", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships/${membershipCreatedViaApi.id}`)
+        .expect(404);
+    });
+
+    it("should fail if the membership does not exist", async () => {
+      return request(app.getHttpServer())
+        .get(`/v2/organizations/${org.id}/teams/${orgTeam.id}/memberships/123132145`)
+        .expect(404);
+    });
+
+    afterAll(async () => {
+      await userRepositoryFixture.deleteByEmail(user.email);
+      await userRepositoryFixture.deleteByEmail(userToInviteViaApi.email);
+      await userRepositoryFixture.deleteByEmail(nonOrgUser.email);
+      await userRepositoryFixture.deleteByEmail(user2.email);
+      await organizationsRepositoryFixture.delete(org.id);
+      await organizationsRepositoryFixture.delete(nonOrgTeam.id);
+      await app.close();
+    });
+  });
+});

apps/api/v2/src/modules/organizations/controllers/teams/memberships/organizations-teams-memberships.controller.ts

@@ -0,0 +1,158 @@
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+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 { CreateOrgTeamMembershipDto } from "@/modules/organizations/inputs/create-organization-team-membership.input";
+import { UpdateOrgTeamMembershipDto } from "@/modules/organizations/inputs/update-organization-team-membership.input";
+import { OrganizationsRepository } from "@/modules/organizations/organizations.repository";
+import {
+  OrgTeamMembershipOutputDto,
+  OrgTeamMembershipsOutputResponseDto,
+  OrgTeamMembershipOutputResponseDto,
+} from "@/modules/organizations/outputs/organization-teams-memberships.output";
+import { OrganizationsTeamsMembershipsService } from "@/modules/organizations/services/organizations-teams-memberships.service";
+import {
+  Controller,
+  UseGuards,
+  Get,
+  Param,
+  ParseIntPipe,
+  Query,
+  Delete,
+  Patch,
+  Post,
+  Body,
+  HttpStatus,
+  HttpCode,
+  UnprocessableEntityException,
+} from "@nestjs/common";
+import { ApiOperation, ApiTags as DocsTags } from "@nestjs/swagger";
+import { plainToClass } from "class-transformer";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+import { SkipTakePagination } from "@calcom/platform-types";
+
+@Controller({
+  path: "/v2/organizations/:orgId/teams/:teamId/memberships",
+  version: API_VERSIONS_VALUES,
+})
+@UseGuards(ApiAuthGuard, IsOrgGuard, RolesGuard, IsTeamInOrg)
+@DocsTags("Organizations Teams")
+export class OrganizationsTeamsMembershipsController {
+  constructor(
+    private organizationsTeamsMembershipsService: OrganizationsTeamsMembershipsService,
+    private readonly organizationsRepository: OrganizationsRepository
+  ) {}
+
+  @Get("/")
+  @ApiOperation({ summary: "Get all the memberships of a team of an organization." })
+  @UseGuards()
+  @Roles("TEAM_ADMIN")
+  @HttpCode(HttpStatus.OK)
+  async getAllOrgTeamMemberships(
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Query() queryParams: SkipTakePagination
+  ): Promise<OrgTeamMembershipsOutputResponseDto> {
+    const { skip, take } = queryParams;
+    const orgTeamMemberships = await this.organizationsTeamsMembershipsService.getPaginatedOrgTeamMemberships(
+      orgId,
+      teamId,
+      skip ?? 0,
+      take ?? 250
+    );
+    return {
+      status: SUCCESS_STATUS,
+      data: orgTeamMemberships.map((membership) =>
+        plainToClass(OrgTeamMembershipOutputDto, membership, { strategy: "excludeAll" })
+      ),
+    };
+  }
+
+  @Get("/:membershipId")
+  @ApiOperation({ summary: "Get the membership of an organization's team by ID" })
+  @UseGuards()
+  @Roles("TEAM_ADMIN")
+  @HttpCode(HttpStatus.OK)
+  async getOrgTeamMembership(
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("membershipId", ParseIntPipe) membershipId: number
+  ): Promise<OrgTeamMembershipOutputResponseDto> {
+    const orgTeamMembership = await this.organizationsTeamsMembershipsService.getOrgTeamMembership(
+      orgId,
+      teamId,
+      membershipId
+    );
+    return {
+      status: SUCCESS_STATUS,
+      data: plainToClass(OrgTeamMembershipOutputDto, orgTeamMembership, { strategy: "excludeAll" }),
+    };
+  }
+
+  @Roles("TEAM_ADMIN")
+  @Delete("/:membershipId")
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Delete the membership of an organization's team by ID" })
+  async deleteOrgTeamMembership(
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("membershipId", ParseIntPipe) membershipId: number
+  ): Promise<OrgTeamMembershipOutputResponseDto> {
+    const membership = await this.organizationsTeamsMembershipsService.deleteOrgTeamMembership(
+      orgId,
+      teamId,
+      membershipId
+    );
+    return {
+      status: SUCCESS_STATUS,
+      data: plainToClass(OrgTeamMembershipOutputDto, membership, { strategy: "excludeAll" }),
+    };
+  }
+
+  @Roles("TEAM_ADMIN")
+  @Patch("/:membershipId")
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: "Update the membership of an organization's team by ID" })
+  async updateOrgTeamMembership(
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Param("membershipId", ParseIntPipe) membershipId: number,
+    @Body() data: UpdateOrgTeamMembershipDto
+  ): Promise<OrgTeamMembershipOutputResponseDto> {
+    const membership = await this.organizationsTeamsMembershipsService.updateOrgTeamMembership(
+      orgId,
+      teamId,
+      membershipId,
+      data
+    );
+    return {
+      status: SUCCESS_STATUS,
+      data: plainToClass(OrgTeamMembershipOutputDto, membership, { strategy: "excludeAll" }),
+    };
+  }
+
+  @Roles("TEAM_ADMIN")
+  @Post("/")
+  @HttpCode(HttpStatus.CREATED)
+  @ApiOperation({ summary: "Create a membership of an organization's team" })
+  async createOrgTeamMembership(
+    @Param("orgId", ParseIntPipe) orgId: number,
+    @Param("teamId", ParseIntPipe) teamId: number,
+    @Body() data: CreateOrgTeamMembershipDto
+  ): Promise<OrgTeamMembershipOutputResponseDto> {
+    const user = await this.organizationsRepository.findOrgUser(Number(orgId), Number(data.userId));
+
+    if (!user) {
+      throw new UnprocessableEntityException("User is not part of the Organization");
+    }
+
+    const membership = await this.organizationsTeamsMembershipsService.createOrgTeamMembership(teamId, data);
+    return {
+      status: SUCCESS_STATUS,
+      data: plainToClass(OrgTeamMembershipOutputDto, membership, { strategy: "excludeAll" }),
+    };
+  }
+}

apps/api/v2/src/modules/organizations/inputs/create-organization-team-membership.input.ts

@@ -0,0 +1,20 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { MembershipRole } from "@prisma/client";
+import { IsBoolean, IsOptional, IsEnum, IsInt } from "class-validator";
+
+export class CreateOrgTeamMembershipDto {
+  @IsInt()
+  readonly userId!: number;
+
+  @IsOptional()
+  @IsBoolean()
+  readonly accepted?: boolean = false;
+
+  @IsEnum(MembershipRole)
+  @ApiProperty({ enum: ["MEMBER", "OWNER", "ADMIN"] })
+  readonly role: MembershipRole = MembershipRole.MEMBER;
+
+  @IsOptional()
+  @IsBoolean()
+  readonly disableImpersonation?: boolean = false;
+}

apps/api/v2/src/modules/organizations/inputs/update-organization-team-membership.input.ts

@@ -0,0 +1,17 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { MembershipRole } from "@prisma/client";
+import { IsBoolean, IsOptional, IsEnum } from "class-validator";
+
+export class UpdateOrgTeamMembershipDto {
+  @IsOptional()
+  @IsBoolean()
+  readonly accepted?: boolean = false;
+
+  @IsEnum(MembershipRole)
+  @ApiProperty({ enum: ["MEMBER", "OWNER", "ADMIN"] })
+  readonly role?: MembershipRole = MembershipRole.MEMBER;
+
+  @IsOptional()
+  @IsBoolean()
+  readonly disableImpersonation?: boolean = false;
+}

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

@@ -1,18 +1,27 @@
+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";
 import { OrganizationsTeamsService } from "@/modules/organizations/services/organizations-teams.service";
 import { OrganizationsUsersService } from "@/modules/organizations/services/organizations-users-service";
 import { OrganizationsService } from "@/modules/organizations/services/organizations.service";
@@ -23,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,
@@ -37,6 +54,12 @@ import { Module } from "@nestjs/common";
     EmailService,
     OrganizationsMembershipRepository,
     OrganizationsMembershipService,
+    OrganizationsEventTypesService,
+    InputOrganizationsEventTypesService,
+    OutputOrganizationsEventTypesService,
+    OrganizationsEventTypesRepository,
+    OrganizationsTeamsMembershipsRepository,
+    OrganizationsTeamsMembershipsService,
   ],
   exports: [
     OrganizationsService,
@@ -46,12 +69,16 @@ import { Module } from "@nestjs/common";
     OrganizationsUsersService,
     OrganizationsMembershipRepository,
     OrganizationsMembershipService,
+    OrganizationsTeamsMembershipsRepository,
+    OrganizationsTeamsMembershipsService,
   ],
   controllers: [
     OrganizationsTeamsController,
     OrganizationsSchedulesController,
     OrganizationsUsersController,
     OrganizationsMembershipsController,
+    OrganizationsEventTypesController,
+    OrganizationsTeamsMembershipsController,
   ],
 })
 export class OrganizationsModule {}

apps/api/v2/src/modules/organizations/outputs/organization-teams-memberships.output.ts

@@ -0,0 +1,57 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { MembershipRole } from "@prisma/client";
+import { Expose, Type } from "class-transformer";
+import { IsArray, IsBoolean, IsEnum, IsInt, IsOptional, IsString, ValidateNested } from "class-validator";
+
+import { ERROR_STATUS, SUCCESS_STATUS } from "@calcom/platform-constants";
+
+export class OrgTeamMembershipOutputDto {
+  @IsInt()
+  @Expose()
+  readonly id!: number;
+
+  @IsInt()
+  @Expose()
+  readonly userId!: number;
+
+  @IsInt()
+  @Expose()
+  readonly teamId!: number;
+
+  @IsBoolean()
+  @Expose()
+  readonly accepted!: boolean;
+
+  @IsString()
+  @ApiProperty({ enum: ["MEMBER", "OWNER", "ADMIN"] })
+  @Expose()
+  readonly role!: MembershipRole;
+
+  @IsOptional()
+  @IsBoolean()
+  @Expose()
+  readonly disableImpersonation?: boolean;
+}
+
+export class OrgTeamMembershipsOutputResponseDto {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @Expose()
+  @ValidateNested()
+  @Type(() => OrgTeamMembershipOutputDto)
+  @IsArray()
+  data!: OrgTeamMembershipOutputDto[];
+}
+
+export class OrgTeamMembershipOutputResponseDto {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @Expose()
+  @ValidateNested()
+  @Type(() => OrgTeamMembershipOutputDto)
+  data!: OrgTeamMembershipOutputDto;
+}

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-memberships.repository.ts

@@ -0,0 +1,70 @@
+import { CreateOrgTeamMembershipDto } from "@/modules/organizations/inputs/create-organization-team-membership.input";
+import { UpdateOrgTeamMembershipDto } from "@/modules/organizations/inputs/update-organization-team-membership.input";
+import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class OrganizationsTeamsMembershipsRepository {
+  constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
+
+  async findOrgTeamMembershipsPaginated(organizationId: number, teamId: number, skip: number, take: number) {
+    return this.dbRead.prisma.membership.findMany({
+      where: {
+        teamId: teamId,
+        team: {
+          parentId: organizationId,
+        },
+      },
+      skip,
+      take,
+    });
+  }
+
+  async findOrgTeamMembership(organizationId: number, teamId: number, membershipId: number) {
+    return this.dbRead.prisma.membership.findUnique({
+      where: {
+        id: membershipId,
+        teamId: teamId,
+        team: {
+          parentId: organizationId,
+        },
+      },
+    });
+  }
+  async deleteOrgTeamMembershipById(organizationId: number, teamId: number, membershipId: number) {
+    return this.dbWrite.prisma.membership.delete({
+      where: {
+        id: membershipId,
+        teamId: teamId,
+        team: {
+          parentId: organizationId,
+        },
+      },
+    });
+  }
+
+  async updateOrgTeamMembershipById(
+    organizationId: number,
+    teamId: number,
+    membershipId: number,
+    data: UpdateOrgTeamMembershipDto
+  ) {
+    return this.dbWrite.prisma.membership.update({
+      data: { ...data },
+      where: {
+        id: membershipId,
+        teamId: teamId,
+        team: {
+          parentId: organizationId,
+        },
+      },
+    });
+  }
+
+  async createOrgTeamMembership(teamId: number, data: CreateOrgTeamMembershipDto) {
+    return this.dbWrite.prisma.membership.create({
+      data: { ...data, teamId: teamId },
+    });
+  }
+}

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(
+  constructor(private readonly dbRead: PrismaReadService) {}
-    private readonly dbRead: PrismaReadService,
-    private readonly dbWrite: PrismaWriteService,
-    private readonly stripeService: StripeService
-  ) {}
 
   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.20";
+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"
+  | "scheduleId"
+  | "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-membership.service.ts

@@ -1,16 +1,12 @@
 import { CreateOrgMembershipDto } from "@/modules/organizations/inputs/create-organization-membership.input";
 import { OrganizationsMembershipRepository } from "@/modules/organizations/repositories/organizations-membership.repository";
-import { OrganizationsTeamsRepository } from "@/modules/organizations/repositories/organizations-teams.repository";
 import { Injectable } from "@nestjs/common";
 
 import { UpdateOrgMembershipDto } from "../inputs/update-organization-membership.input";
 
 @Injectable()
 export class OrganizationsMembershipService {
-  constructor(
+  constructor(private readonly organizationsMembershipRepository: OrganizationsMembershipRepository) {}
-    private readonly organizationsMembershipRepository: OrganizationsMembershipRepository,
-    private readonly organizationsTeamsRepository: OrganizationsTeamsRepository
-  ) {}
 
   async getOrgMembership(organizationId: number, membershipId: number) {
     const membership = await this.organizationsMembershipRepository.findOrgMembership(
@@ -30,11 +26,11 @@ export class OrganizationsMembershipService {
   }
 
   async deleteOrgMembership(organizationId: number, membershipId: number) {
-    const memberships = await this.organizationsMembershipRepository.deleteOrgMembership(
+    const membership = await this.organizationsMembershipRepository.deleteOrgMembership(
       organizationId,
       membershipId
     );
-    return memberships;
+    return membership;
   }
 
   async updateOrgMembership(organizationId: number, membershipId: number, data: UpdateOrgMembershipDto) {

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

@@ -0,0 +1,68 @@
+import { CreateOrgTeamMembershipDto } from "@/modules/organizations/inputs/create-organization-team-membership.input";
+import { UpdateOrgTeamMembershipDto } from "@/modules/organizations/inputs/update-organization-team-membership.input";
+import { OrganizationsTeamsMembershipsRepository } from "@/modules/organizations/repositories/organizations-teams-memberships.repository";
+import { Injectable, NotFoundException } from "@nestjs/common";
+
+@Injectable()
+export class OrganizationsTeamsMembershipsService {
+  constructor(
+    private readonly organizationsTeamsMembershipsRepository: OrganizationsTeamsMembershipsRepository
+  ) {}
+
+  async createOrgTeamMembership(teamId: number, data: CreateOrgTeamMembershipDto) {
+    const teamMembership = await this.organizationsTeamsMembershipsRepository.createOrgTeamMembership(
+      teamId,
+      data
+    );
+    return teamMembership;
+  }
+
+  async getPaginatedOrgTeamMemberships(organizationId: number, teamId: number, skip = 0, take = 250) {
+    const teamMemberships =
+      await this.organizationsTeamsMembershipsRepository.findOrgTeamMembershipsPaginated(
+        organizationId,
+        teamId,
+        skip,
+        take
+      );
+    return teamMemberships;
+  }
+
+  async getOrgTeamMembership(organizationId: number, teamId: number, membershipId: number) {
+    const teamMemberships = await this.organizationsTeamsMembershipsRepository.findOrgTeamMembership(
+      organizationId,
+      teamId,
+      membershipId
+    );
+
+    if (!teamMemberships) {
+      throw new NotFoundException("Organization's Team membership not found");
+    }
+
+    return teamMemberships;
+  }
+
+  async updateOrgTeamMembership(
+    organizationId: number,
+    teamId: number,
+    membershipId: number,
+    data: UpdateOrgTeamMembershipDto
+  ) {
+    const teamMembership = await this.organizationsTeamsMembershipsRepository.updateOrgTeamMembershipById(
+      organizationId,
+      teamId,
+      membershipId,
+      data
+    );
+    return teamMembership;
+  }
+
+  async deleteOrgTeamMembership(organizationId: number, teamId: number, membershipId: number) {
+    const teamMembership = await this.organizationsTeamsMembershipsRepository.deleteOrgTeamMembershipById(
+      organizationId,
+      teamId,
+      membershipId
+    );
+    return teamMembership;
+  }
+}

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

@@ -29,7 +29,7 @@ export class OrganizationsTeamsService {
   async createOrgTeam(organizationId: number, data: CreateOrgTeamDto, user: UserWithProfile) {
     const team = await this.organizationsTeamRepository.createOrgTeam(organizationId, data);
     if (user.role !== "ADMIN") {
-      await this.membershipsRepository.createMembership(team.id, user.id, "OWNER");
+      await this.membershipsRepository.createMembership(team.id, user.id, "OWNER", true);
     }
     return team;
   }

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.20";
 import { Team } from "@calcom/prisma/client";
 
 @Injectable()

apps/api/v2/src/modules/selected-calendars/controllers/selected-calendars.controller.e2e-spec.ts

@@ -0,0 +1,156 @@
+import { bootstrap } from "@/app";
+import { AppModule } from "@/app.module";
+import { CalendarsService } from "@/ee/calendars/services/calendars.service";
+import { HttpExceptionFilter } from "@/filters/http-exception.filter";
+import { PrismaExceptionFilter } from "@/filters/prisma-exception.filter";
+import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { SelectedCalendarOutputResponseDto } from "@/modules/selected-calendars/outputs/selected-calendars.output";
+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 { PlatformOAuthClient, Team, User, Credential } from "@prisma/client";
+import * as request from "supertest";
+import { CredentialsRepositoryFixture } from "test/fixtures/repository/credentials.repository.fixture";
+import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
+import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
+import { TokensRepositoryFixture } from "test/fixtures/repository/tokens.repository.fixture";
+import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
+import { CalendarsServiceMock } from "test/mocks/calendars-service-mock";
+
+import { APPLE_CALENDAR_TYPE, APPLE_CALENDAR_ID } from "@calcom/platform-constants";
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+
+const CLIENT_REDIRECT_URI = "http://localhost:5555";
+
+describe("Platform Selected Calendars Endpoints", () => {
+  let app: INestApplication;
+
+  let oAuthClient: PlatformOAuthClient;
+  let organization: Team;
+  let userRepositoryFixture: UserRepositoryFixture;
+  let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
+  let teamRepositoryFixture: TeamRepositoryFixture;
+  let tokensRepositoryFixture: TokensRepositoryFixture;
+  let credentialsRepositoryFixture: CredentialsRepositoryFixture;
+  let appleCalendarCredentials: Credential;
+  let user: User;
+  let accessTokenSecret: string;
+  let refreshTokenSecret: string;
+
+  beforeAll(async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [PrismaExceptionFilter, HttpExceptionFilter],
+      imports: [AppModule, UsersModule, TokensModule],
+    })
+      .overrideGuard(PermissionsGuard)
+      .useValue({
+        canActivate: () => true,
+      })
+
+      .compile();
+
+    app = moduleRef.createNestApplication();
+    bootstrap(app as NestExpressApplication);
+
+    oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
+    userRepositoryFixture = new UserRepositoryFixture(moduleRef);
+    teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+    tokensRepositoryFixture = new TokensRepositoryFixture(moduleRef);
+    credentialsRepositoryFixture = new CredentialsRepositoryFixture(moduleRef);
+    organization = await teamRepositoryFixture.create({ name: "organization" });
+    oAuthClient = await createOAuthClient(organization.id);
+    user = await userRepositoryFixture.createOAuthManagedUser("office365-connect@gmail.com", oAuthClient.id);
+    const tokens = await tokensRepositoryFixture.createTokens(user.id, oAuthClient.id);
+    accessTokenSecret = tokens.accessToken;
+    refreshTokenSecret = tokens.refreshToken;
+    appleCalendarCredentials = await credentialsRepositoryFixture.create(
+      APPLE_CALENDAR_TYPE,
+      {},
+      user.id,
+      APPLE_CALENDAR_ID
+    );
+    await app.init();
+    jest
+      .spyOn(CalendarsService.prototype, "getCalendars")
+      .mockImplementation(CalendarsServiceMock.prototype.getCalendars);
+  });
+
+  async function createOAuthClient(organizationId: number) {
+    const data = {
+      logo: "logo-url",
+      name: "name",
+      redirectUris: [CLIENT_REDIRECT_URI],
+      permissions: 32,
+    };
+    const secret = "secret";
+
+    const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
+    return client;
+  }
+
+  it("should be defined", () => {
+    expect(oauthClientRepositoryFixture).toBeDefined();
+    expect(userRepositoryFixture).toBeDefined();
+    expect(oAuthClient).toBeDefined();
+    expect(accessTokenSecret).toBeDefined();
+    expect(refreshTokenSecret).toBeDefined();
+    expect(user).toBeDefined();
+  });
+
+  it(`POST /v2/selected-calendars: it should respond with a 201 returning back the user added selected calendar`, async () => {
+    const body = {
+      integration: appleCalendarCredentials.type,
+      externalId: "https://caldav.icloud.com/20961146906/calendars/83C4F9A1-F1D0-41C7-8FC3-0B$9AE22E813/",
+      credentialId: appleCalendarCredentials.id,
+    };
+
+    await request(app.getHttpServer())
+      .post("/v2/selected-calendars")
+      .set("Authorization", `Bearer ${accessTokenSecret}`)
+      .send(body)
+      .expect(201)
+      .then(async (response) => {
+        const responseBody: SelectedCalendarOutputResponseDto = response.body;
+
+        expect(responseBody.status).toEqual(SUCCESS_STATUS);
+        expect(responseBody.data).toBeDefined();
+        expect(responseBody.data.credentialId).toEqual(body.credentialId);
+        expect(responseBody.data.integration).toEqual(body.integration);
+        expect(responseBody.data.externalId).toEqual(body.externalId);
+        expect(responseBody.data.userId).toEqual(user.id);
+      });
+  });
+
+  it(`DELETE /v2/selected-calendars: it should respond with a 200 returning back the user deleted selected calendar`, async () => {
+    const integration = appleCalendarCredentials.type;
+    const externalId =
+      "https://caldav.icloud.com/20961146906/calendars/83C4F9A1-F1D0-41C7-8FC3-0B$9AE22E813/";
+    const credentialId = appleCalendarCredentials.id;
+
+    await request(app.getHttpServer())
+      .delete(
+        `/v2/selected-calendars?credentialId=${credentialId}&integration=${integration}&externalId=${externalId}`
+      )
+      .set("Authorization", `Bearer ${accessTokenSecret}`)
+      .expect(200)
+      .then(async (response) => {
+        const responseBody: SelectedCalendarOutputResponseDto = response.body;
+
+        expect(responseBody.status).toEqual(SUCCESS_STATUS);
+        expect(responseBody.data).toBeDefined();
+        expect(responseBody.data.credentialId).toEqual(credentialId);
+        expect(responseBody.data.externalId).toEqual(externalId);
+        expect(responseBody.data.integration).toEqual(integration);
+        expect(responseBody.data.userId).toEqual(user.id);
+      });
+  });
+
+  afterAll(async () => {
+    await oauthClientRepositoryFixture.delete(oAuthClient.id);
+    await teamRepositoryFixture.delete(organization.id);
+    await userRepositoryFixture.deleteByEmail(user.email);
+    await app.close();
+  });
+});

apps/api/v2/src/modules/selected-calendars/controllers/selected-calendars.controller.ts

@@ -0,0 +1,76 @@
+import { CalendarsRepository } from "@/ee/calendars/calendars.repository";
+import { CalendarsService } from "@/ee/calendars/services/calendars.service";
+import { API_VERSIONS_VALUES } from "@/lib/api-versions";
+import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
+import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
+import {
+  SelectedCalendarsInputDto,
+  SelectedCalendarsQueryParamsInputDto,
+} from "@/modules/selected-calendars/inputs/selected-calendars.input";
+import {
+  SelectedCalendarOutputResponseDto,
+  SelectedCalendarOutputDto,
+} from "@/modules/selected-calendars/outputs/selected-calendars.output";
+import { SelectedCalendarsRepository } from "@/modules/selected-calendars/selected-calendars.repository";
+import { UserWithProfile } from "@/modules/users/users.repository";
+import { Body, Controller, Post, UseGuards, Delete, Query } from "@nestjs/common";
+import { ApiTags as DocsTags } from "@nestjs/swagger";
+import { plainToClass } from "class-transformer";
+
+import { SUCCESS_STATUS } from "@calcom/platform-constants";
+
+@Controller({
+  path: "/v2/selected-calendars",
+  version: API_VERSIONS_VALUES,
+})
+@DocsTags("Selected-Calendars")
+export class SelectedCalendarsController {
+  constructor(
+    private readonly calendarsRepository: CalendarsRepository,
+    private readonly selectedCalendarsRepository: SelectedCalendarsRepository,
+    private readonly calendarsService: CalendarsService
+  ) {}
+
+  @Post("/")
+  @UseGuards(ApiAuthGuard)
+  async addSelectedCalendar(
+    @Body() input: SelectedCalendarsInputDto,
+    @GetUser() user: UserWithProfile
+  ): Promise<SelectedCalendarOutputResponseDto> {
+    const { integration, externalId, credentialId } = input;
+    await this.calendarsService.checkCalendarCredentials(Number(credentialId), user.id);
+
+    const newlyAddedCalendarEntry = await this.selectedCalendarsRepository.addUserSelectedCalendar(
+      user.id,
+      integration,
+      externalId,
+      credentialId
+    );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: plainToClass(SelectedCalendarOutputDto, newlyAddedCalendarEntry, { strategy: "excludeAll" }),
+    };
+  }
+
+  @Delete("/")
+  @UseGuards(ApiAuthGuard)
+  async removeSelectedCalendar(
+    @Query() queryParams: SelectedCalendarsQueryParamsInputDto,
+    @GetUser() user: UserWithProfile
+  ): Promise<SelectedCalendarOutputResponseDto> {
+    const { integration, externalId, credentialId } = queryParams;
+    await this.calendarsService.checkCalendarCredentials(Number(credentialId), user.id);
+
+    const removedCalendarEntry = await this.selectedCalendarsRepository.removeUserSelectedCalendar(
+      user.id,
+      integration,
+      externalId
+    );
+
+    return {
+      status: SUCCESS_STATUS,
+      data: plainToClass(SelectedCalendarOutputDto, removedCalendarEntry, { strategy: "excludeAll" }),
+    };
+  }
+}

apps/api/v2/src/modules/selected-calendars/inputs/selected-calendars.input.ts

@@ -0,0 +1,23 @@
+import { IsInt, IsString } from "class-validator";
+
+export class SelectedCalendarsInputDto {
+  @IsString()
+  readonly integration!: string;
+
+  @IsString()
+  readonly externalId!: string;
+
+  @IsInt()
+  readonly credentialId!: number;
+}
+
+export class SelectedCalendarsQueryParamsInputDto {
+  @IsString()
+  readonly integration!: string;
+
+  @IsString()
+  readonly externalId!: string;
+
+  @IsString()
+  readonly credentialId!: string;
+}

apps/api/v2/src/modules/selected-calendars/outputs/selected-calendars.output.ts

@@ -0,0 +1,34 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { Expose, Type } from "class-transformer";
+import { IsInt, IsString, ValidateNested, IsEnum } from "class-validator";
+
+import { ERROR_STATUS, SUCCESS_STATUS } from "@calcom/platform-constants";
+
+export class SelectedCalendarOutputDto {
+  @IsInt()
+  @Expose()
+  readonly userId!: number;
+
+  @IsString()
+  @Expose()
+  readonly integration!: string;
+
+  @IsString()
+  @Expose()
+  readonly externalId!: string;
+
+  @IsInt()
+  @Expose()
+  readonly credentialId!: number | null;
+}
+
+export class SelectedCalendarOutputResponseDto {
+  @ApiProperty({ example: SUCCESS_STATUS, enum: [SUCCESS_STATUS, ERROR_STATUS] })
+  @IsEnum([SUCCESS_STATUS, ERROR_STATUS])
+  status!: typeof SUCCESS_STATUS | typeof ERROR_STATUS;
+
+  @Expose()
+  @ValidateNested()
+  @Type(() => SelectedCalendarOutputDto)
+  data!: SelectedCalendarOutputDto;
+}

apps/api/v2/src/modules/selected-calendars/selected-calendars.module.ts

@@ -1,10 +1,24 @@
+import { CalendarsRepository } from "@/ee/calendars/calendars.repository";
+import { CalendarsService } from "@/ee/calendars/services/calendars.service";
+import { AppsRepository } from "@/modules/apps/apps.repository";
+import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
+import { SelectedCalendarsController } from "@/modules/selected-calendars/controllers/selected-calendars.controller";
 import { SelectedCalendarsRepository } from "@/modules/selected-calendars/selected-calendars.repository";
+import { UsersRepository } from "@/modules/users/users.repository";
 import { Module } from "@nestjs/common";
 
 @Module({
   imports: [PrismaModule],
-  providers: [SelectedCalendarsRepository],
+  providers: [
+    SelectedCalendarsRepository,
+    CalendarsRepository,
+    CalendarsService,
+    UsersRepository,
+    CredentialsRepository,
+    AppsRepository,
+  ],
+  controllers: [SelectedCalendarsController],
   exports: [SelectedCalendarsRepository],
 })
 export class SelectedCalendarsModule {}

apps/api/v2/src/modules/selected-calendars/selected-calendars.repository.ts

@@ -37,4 +37,41 @@ export class SelectedCalendarsRepository {
       },
     });
   }
+
+  async addUserSelectedCalendar(
+    userId: number,
+    integration: string,
+    externalId: string,
+    credentialId: number
+  ) {
+    return await this.dbWrite.prisma.selectedCalendar.upsert({
+      where: {
+        userId_integration_externalId: {
+          userId,
+          integration,
+          externalId,
+        },
+      },
+      create: {
+        userId,
+        integration,
+        externalId,
+        credentialId,
+      },
+      // already exists
+      update: {},
+    });
+  }
+
+  async removeUserSelectedCalendar(userId: number, integration: string, externalId: string) {
+    return await this.dbWrite.prisma.selectedCalendar.delete({
+      where: {
+        userId_integration_externalId: {
+          userId,
+          externalId,
+          integration,
+        },
+      },
+    });
+  }
 }

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 { getAvailableSlots } from "@calcom/platform-libraries-0.0.20";
-import type { AvailableSlotsType } from "@calcom/platform-libraries-0.0.18";
+import type { AvailableSlotsType } from "@calcom/platform-libraries-0.0.20";
 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.20";
 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.20";
 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 { cityTimezonesHandler } from "@calcom/platform-libraries-0.0.20";
-import type { CityTimezones } from "@calcom/platform-libraries-0.0.18";
+import type { CityTimezones } from "@calcom/platform-libraries-0.0.20";
 
 @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: {
@@ -159,10 +172,6 @@ export class UsersRepository {
     if (userInput.weekStart) {
       userInput.weekStart = userInput.weekStart;
     }
-
-    if (userInput.timeZone) {
-      userInput.timeZone = capitalizeTimezone(userInput.timeZone);
-    }
   }
 
   setDefaultSchedule(userId: number, scheduleId: number) {
@@ -194,17 +203,3 @@ export class UsersRepository {
     return profiles.map((profile) => profile.user);
   }
 }
-
-function capitalizeTimezone(timezone: string) {
-  const segments = timezone.split("/");
-
-  const capitalizedSegments = segments.map((segment) => {
-    return capitalize(segment);
-  });
-
-  return capitalizedSegments.join("/");
-}
-
-function capitalize(str: string) {
-  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-}