@notionhq/apps 0.0.26 → 0.0.28

package/dist/calendar.generated.d.ts

@@ -1,127 +1,215 @@
 import type { ConnectionActionInvoker } from "./connection-actions.js";
 /**
- * Script input for the "List available calendar resources (such as conference rooms)." effect (`calendar.listCalendarResources`),
+ * Script input for the "Cancel calendar events." effect (`calendar.cancelEvents`),
  * derived from its Tool Core definition's call_function input projection.
  *
- * Search for resources (often conference rooms) and check their availability for specific time slots.
- * Resources are scoped to a single account; pass `calendar` to target the account of the event you intend to attach the rooms to.
- * Only works with Google Workspace accounts that have admin permissions to view calendar resources.
- * Use this tool to find rooms when creating in-person meetings.
- * Pass multiple meeting times in timeSlots to get available rooms for each time slot independently.
+ * If the event has an organizer and it's not the user, then it cannot be canceled but we can update the user's response with another tool.
+ * If the event has attendees, they will receive a notification of the cancellation.
  */
-export type ListCalendarResourcesScriptInput = {
+export type CancelEventsScriptInput = {
     /**
-     * Specific time slots to check. Returns available resources for each time slot independently.
+     * Events to cancel.
      */
-    timeSlots: Array<{
+    events: Array<{
         /**
-         * Start of the time slot to check, as an ISO 8601 date-time.
+         * Calendar containing the event.
          */
-        startAt: string;
+        calendar: {
+            /**
+             * Account that owns the event calendar.
+             */
+            accountId: string;
+            /**
+             * Event calendar identifier within the account.
+             */
+            calendarId: string;
+        };
         /**
-         * End of the time slot to check, as an ISO 8601 date-time.
+         * Identifier of the event to cancel.
          */
-        endAt: string;
+        eventId: string;
+        /**
+         * Optional summary of the event, used by agent UI.
+         */
+        eventSummary?: string;
     }>;
-    /**
-     * Minimum room capacity (number of people). MUST include the meeting organizer/user themselves in the count. For a 1-on-1, pass 2. For a meeting with N invitees besides the user, pass N+1.
-     */
-    minCapacity: number;
-    /**
-     * Maximum number of resources to return per time slot (default: 20, max: 40)
-     */
-    maxCount?: number;
-    /**
-     * If true, do not narrow rooms to the user's working-location building for this day. Set this when the user is explicitly asking about rooms in a different office (e.g. for a visiting team).
-     */
-    ignoreWorkingLocation?: boolean;
+};
+/**
+ * Canonical Tool Core output for the "Cancel calendar events." effect (`calendar.cancelEvents`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type CancelEventsScriptOutput = {
+    canceledEvents: Array<{
+        calendar: {
+            accountId: string;
+            calendarId: string;
+        };
+        eventId: string;
+        /**
+         * Optional summary of the event, used by agent UI.
+         */
+        eventSummary?: string;
+    }>;
+    errors?: Array<{
+        /**
+         * An identifier for the item that failed (e.g., event summary for creation, event ID for updates/cancellations)
+         */
+        identifier: string;
+        /**
+         * Description of the error that occurred
+         */
+        errorMessage: string;
+    }>;
+};
+/**
+ * Script input for the "Create calendar events." effect (`calendar.createEvents`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * Events can be created on different calendars.
+ */
+export type CreateEventsScriptInput = {
     /**
      * Date-times of returned events will be expressed in this time-zone
      */
     timeZone: string;
     /**
-     * Calendar of the event the rooms will be attached to. Rooms are scoped to a single account.
+     * Events to create.
      */
-    calendar?: {
+    events: Array<{
         /**
-         * Account that owns the target calendar.
+         * Title of the event.
          */
-        accountId: string;
+        summary: string;
         /**
-         * Target calendar identifier within the account.
+         * Description of the event.
          */
-        calendarId: string;
-    };
-};
-/**
- * Canonical Tool Core output for the "List available calendar resources (such as conference rooms)." effect (`calendar.listCalendarResources`).
- * This is the definition's output schema; the effect's script surface may
- * re-encode it before returning.
- */
-export type ListCalendarResourcesScriptOutput = {
-    /**
-     * Results for each requested time slot, with available rooms sorted by capacity
-     */
-    resultsBySlot: Array<{
+        description?: string;
         /**
-         * The time slot being checked
+         * Physical location where the event takes place, or remote conference link/info.
          */
-        timeSlot: {
-            startAt: string;
-            endAt: string;
-        };
+        location?: string;
         /**
-         * Available conference rooms for this time slot, sorted by increasing capacity (smallest rooms first)
+         * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
          */
-        availableResources: Array<{
+        recurrenceRules?: Array<string>;
+        /**
+         * When the event is happening
+         */
+        period: {
             /**
-             * Use this as the email when adding rooms to events
+             * Whether the event period uses all-day dates or date-times.
              */
-            resourceEmail: string;
+            type: "DATE";
             /**
-             * Display name of the conference room
+             * Start of the event.
              */
-            resourceName: string;
+            start: {
+                /**
+                 * Date in ISO 8601 format (no time)
+                 */
+                date: string;
+            };
             /**
-             * Building information
+             * End of the event.
              */
-            building?: {
-                buildingId: string;
-                buildingName?: string;
+            end: {
+                /**
+                 * Date in ISO 8601 format (no time)
+                 */
+                date: string;
             };
+        } | {
             /**
-             * Maximum number of people the room can accommodate
+             * Whether the event period uses all-day dates or date-times.
              */
-            capacity?: number;
+            type: "DATE_TIME";
             /**
-             * Floor location
+             * Start of the event.
              */
-            floor?: string;
+            start: {
+                /**
+                 * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset, or without TZ offset if `timeZone` is specified in which case will be interpreted as local time in that timeZone
+                 */
+                dateTime: string;
+                /**
+                 * IANA time zone for the event start date-time.
+                 */
+                timeZone?: string;
+            };
             /**
-             * Room description
+             * End of the event.
              */
-            description?: string;
+            end: {
+                /**
+                 * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset, or without TZ offset if `timeZone` is specified in which case will be interpreted as local time in that timeZone
+                 */
+                dateTime: string;
+                /**
+                 * IANA time zone for the event end date-time.
+                 */
+                timeZone?: string;
+            };
+        };
+        /**
+         * Attendees to invite to the event
+         */
+        attendees?: Array<{
+            /**
+             * Email address of the attendee.
+             */
+            email: string;
+            /**
+             * Totally optional, provide only if you are sure of the attendee's name
+             */
+            displayName?: string;
+            /**
+             * Set only if the user was explicit about an attendee not being required
+             */
+            isOptional?: boolean;
         }>;
+        /**
+         * Resources (such as rooms) to invite to the event. Must be from the same account as `event.calendar`.
+         */
+        resources?: Array<{
+            /**
+             * Email address of the resource.
+             */
+            email?: string;
+            /**
+             * Display name of the resource.
+             */
+            displayName?: string;
+            /**
+             * Set only if the user was explicit about a resource not being required
+             */
+            isOptional: boolean;
+        }>;
+        /**
+         * Will create the event on the primary, default calendar if not specified.
+         */
+        calendar?: {
+            /**
+             * Account that owns the target calendar.
+             */
+            accountId: string;
+            /**
+             * Target calendar identifier within the account.
+             */
+            calendarId: string;
+        };
+        /**
+         * Whether to disable conferencing for this event.
+         */
+        disableConferencing?: boolean;
     }>;
 };
 /**
- * Script input for the "Fetch list of calendars of the user." effect (`calendar.listCalendars`),
- * derived from its Tool Core definition's call_function input projection.
- *
- * List of calendars grouped by account.
- */
-export type ListCalendarsScriptInput = {
-    /**
-     * Return only accounts linked to these email addresses. Useful to get calendars from a work account only for example. Do not specify if you are interested in getting the whole picture of someone's agenda across work and personal accounts.
-     */
-    onlyAccountEmails?: Array<string>;
-};
-/**
- * Canonical Tool Core output for the "Fetch list of calendars of the user." effect (`calendar.listCalendars`).
+ * Canonical Tool Core output for the "Create calendar events." effect (`calendar.createEvents`).
  * This is the definition's output schema; the effect's script surface may
  * re-encode it before returning.
  */
-export type ListCalendarsScriptOutput = {
+export type CreateEventsScriptOutput = {
     accounts: Array<{
         accountId: string;
         /**
@@ -190,140 +278,1325 @@ export type ListCalendarsScriptOutput = {
              * The email address of the owner of this calendar.
              */
             ownerEmail?: string;
-        }>;
-    }>;
-};
-/**
- * Script input for the "List contacts" effect (`calendar.listContacts`),
- * derived from its Tool Core definition's call_function input projection.
- *
- * List the user's contacts from different accounts. Returns contact information including email addresses, names, phone numbers, and profile photos.
- */
-export type ListContactsScriptInput = {
-    /**
-     * Optional search queries to filter contacts by name or email. Results matching any query are included.
-     */
-    queries?: Array<string>;
-};
-/**
- * Canonical Tool Core output for the "List contacts" effect (`calendar.listContacts`).
- * This is the definition's output schema; the effect's script surface may
- * re-encode it before returning.
- */
-export type ListContactsScriptOutput = {
-    accounts: Array<{
-        accountId: string;
-        /**
-         * Google, Apple iCloud, Outlook, etc.
-         */
-        providerName: string;
-        /**
-         * The user email associated with this account. Useful to know if this account and its data should be used depending on context.
-         */
-        email?: string;
-        /**
-         * Whether this account is work-related or a personal account, if we know this information.
-         */
-        category?: "work" | "personal";
-        capabilities: {
-            /**
-             * Does this account expose any calendars?
-             */
-            readCalendars: boolean;
-            /**
-             * Can we read calendar events from calendars of this account?
-             */
-            readEvents: boolean;
-            /**
-             * Can we write events in some calendars of this account? Calendars themselves might have their own set of restrictions.
-             */
-            writeEvents: boolean;
-            /**
-             * Can we use a text search query to find events in the calendars of this account?
-             */
-            searchEvents: boolean;
-            /**
-             * Does this account expose contacts?
-             */
-            readContacts: boolean;
-        };
-        /**
-         * User can access the events of co-workers having an email address with one of these domains
-         */
-        coworkersEmailDomains?: Array<string>;
-        contacts: Array<{
-            /**
-             * Unique identifier for the contact
-             */
-            id: string;
-            /**
-             * Primary email address of the contact
-             */
-            email: string;
-            /**
-             * Additional email addresses for this contact
-             */
-            alternateEmails?: Array<string>;
-            /**
-             * Display name of the contact
-             */
-            displayName?: string;
-            /**
-             * Phone numbers associated with this contact
-             */
-            phoneNumbers?: Array<{
+            createdEvents: Array<{
+                calendar: {
+                    accountId: string;
+                    calendarId: string;
+                };
+                eventId: string;
+                summary: string;
+                description?: string;
                 /**
-                 * The type of phone number (e.g., home, work, mobile)
+                 * Physical location where the event takes place, or remote conference link/info.
                  */
-                type?: string;
+                location?: string;
+                /**
+                 * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
+                 */
+                recurrenceRules?: Array<string>;
+                /**
+                 * The data provider this event belongs to
+                 */
+                provider?: "google" | "notion" | "icloud" | "outlook";
+                /**
+                 * The URL to view the event in the Calendar app.
+                 */
+                webUrl: string;
+                /**
+                 * When the event is happening
+                 */
+                period: {
+                    type: "DATE";
+                    start: {
+                        /**
+                         * Date in ISO 8601 format (no time)
+                         */
+                        date: string;
+                    };
+                    end: {
+                        /**
+                         * Date in ISO 8601 format (no time)
+                         */
+                        date: string;
+                    };
+                } | {
+                    type: "DATE_TIME";
+                    start: {
+                        /**
+                         * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
+                         */
+                        dateTime: string;
+                        timeZone?: string;
+                    };
+                    end: {
+                        /**
+                         * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
+                         */
+                        dateTime: string;
+                        timeZone?: string;
+                    };
+                };
+                /**
+                 * Whether it's part of a recurring event series
+                 */
+                isRecurring: boolean;
+                /**
+                 * If true, the event does not block time on the calendar. This is equivalent to setting `Show me as to Available` in the Calendar UI.
+                 */
+                isTransparent: boolean;
+                /**
+                 * Is the event an auto-blocking event created from another event? Used to create blocked events on a calendar from events on another calendar. You can ignore auto-blocked events if there are events happening at the exact same time on other calendars.
+                 */
+                isAutoBlock: boolean;
+                /**
+                 * What kind of event is it? Standard, out of office, birthday...
+                 */
+                eventType?: "fromGmail" | "default" | "focusTime" | "outOfOffice" | "birthday" | "availability";
+                /**
+                 * Is an event confirmed, tentative or cancelled? This is different from the user's RSVP
+                 */
+                eventStatus?: "confirmed" | "tentative" | "cancelled";
+                /**
+                 * Whether it's a meeting, aka an event with attendees listed
+                 */
+                isMeeting: boolean;
+                conferencingEntryPoints?: Array<{
+                    uri: string;
+                    accessCode?: string;
+                    entryPointType?: "video" | "phone" | "sip" | "more";
+                    label?: string;
+                    meetingCode?: string;
+                    passcode?: string;
+                    password?: string;
+                    pin?: string;
+                    notes?: string;
+                    signature?: string;
+                }>;
+                /**
+                 * The URL to join the video conference, if available
+                 */
+                conferencingUrl?: string;
+                /**
+                 * The calendar user's RSVP status
+                 */
+                responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+                creator?: {
+                    /**
+                     * Whether this entry represents the calendar user
+                     */
+                    isSelf: boolean;
+                    displayName?: string;
+                    email?: string;
+                };
+                organizer?: {
+                    /**
+                     * Whether this entry represents the calendar user
+                     */
+                    isSelf: boolean;
+                    displayName?: string;
+                    email?: string;
+                };
+                attendees?: Array<{
+                    /**
+                     * Whether this entry represents the calendar user
+                     */
+                    isSelf: boolean;
+                    displayName?: string;
+                    email?: string;
+                    isOptional: boolean;
+                    isOrganizer?: boolean;
+                    /**
+                     * The calendar user's RSVP status
+                     */
+                    responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+                }>;
+                resources?: Array<{
+                    displayName?: string;
+                    email?: string;
+                    isOptional: boolean;
+                    /**
+                     * The calendar user's RSVP status
+                     */
+                    responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+                }>;
+                colors?: {
+                    foreground?: string;
+                    background?: string;
+                };
+                attachments?: Array<{
+                    url: string;
+                    mimeType?: string;
+                    title?: string;
+                    notionWorkspaceId?: string;
+                }>;
+            }>;
+        }>;
+    }>;
+    errors?: Array<{
+        /**
+         * An identifier for the item that failed (e.g., event summary for creation, event ID for updates/cancellations)
+         */
+        identifier: string;
+        /**
+         * Description of the error that occurred
+         */
+        errorMessage: string;
+    }>;
+};
+/**
+ * Script input for the "Create a scheduling link" effect (`calendar.createSchedulingLink`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * Create a scheduling link (booking page) so others can book time on the user's calendar during specified availability windows.
+ */
+export type CreateSchedulingLinkScriptInput = {
+    /**
+     * Calendar where meetings booked through this scheduling link will be created
+     */
+    bookingCalendar: {
+        /**
+         * Account that owns the booking calendar.
+         */
+        accountId: string;
+        /**
+         * Booking calendar identifier within the account.
+         */
+        calendarId: string;
+    };
+    /**
+     * Calendars to check for conflicts when determining available time slots. Events on these calendars will block booking availability.
+     */
+    conflictCalendars?: Array<{
+        /**
+         * Account that owns the conflict calendar.
+         */
+        accountId: string;
+        /**
+         * Conflict calendar identifier within the account.
+         */
+        calendarId: string;
+    }>;
+    /**
+     * Title of the scheduling link, shown on the booking page
+     */
+    title?: string;
+    /**
+     * Description shown to invitees on the booking page
+     */
+    description?: string;
+    /**
+     * Meeting duration in minutes
+     */
+    duration: number;
+    /**
+     * Time windows when the user is available for bookings
+     */
+    timeRanges: Array<{
+        /**
+         * Start of availability window in ISO 8601 format with timezone offset, e.g. '2024-08-22T09:00:00-04:00'
+         */
+        startDate: string;
+        /**
+         * End of availability window in ISO 8601 format with timezone offset, e.g. '2024-08-22T17:00:00-04:00'
+         */
+        endDate: string;
+        /**
+         * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
+         */
+        recurrence?: Array<string>;
+    }>;
+    /**
+     * Type of scheduling link: 'singleUse' (one booking only), 'multiUse' (multiple bookings), 'recurring' (repeating weekly availability). Inferred from timeRanges if not provided.
+     */
+    type?: "singleUse" | "multiUse" | "recurring";
+    /**
+     * Custom URL slug for the scheduling link (letters, numbers, hyphens, underscores only). Must be between 1 and 32 characters. Auto-generated if not provided.
+     */
+    alias?: string;
+    /**
+     * If true (default), uses the user's default video conferencing provider
+     */
+    useDefaultConferencing?: boolean;
+    /**
+     * Minimum notice period in minutes before a meeting can be booked
+     */
+    minLeadTime?: number;
+    /**
+     * Maximum advance booking window in minutes (how far into the future meetings can be booked)
+     */
+    maxLeadTime?: number;
+    /**
+     * ISO 8601 date-time when this scheduling link expires and can no longer accept bookings
+     */
+    expirationDate?: string;
+};
+/**
+ * Canonical Tool Core output for the "Create a scheduling link" effect (`calendar.createSchedulingLink`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type CreateSchedulingLinkScriptOutput = {
+    /**
+     * The created scheduling link
+     */
+    schedulingLink?: {
+        /**
+         * Unique ID of the created scheduling link
+         */
+        id: string;
+        /**
+         * Short ID used in the scheduling link URL
+         */
+        shortId: string;
+        /**
+         * Current booking calendar for this scheduling link
+         */
+        bookingCalendarRef: {
+            accountId: string;
+            calendarId: string;
+        };
+        /**
+         * Custom URL slug for the scheduling link
+         */
+        alias?: string;
+        /**
+         * The resolved type of the link
+         */
+        type?: "singleUse" | "multiUse" | "recurring";
+        /**
+         * Status of the scheduling link
+         */
+        status: string;
+        title?: string;
+        description?: string;
+        duration?: number;
+        /**
+         * Full URL where invitees can book a meeting
+         */
+        schedulingLinkUrl?: string;
+        timeRanges: Array<{
+            /**
+             * Start of availability window in ISO 8601 format with timezone offset, e.g. '2024-08-22T09:00:00-04:00'
+             */
+            startDate: string;
+            /**
+             * End of availability window in ISO 8601 format with timezone offset, e.g. '2024-08-22T17:00:00-04:00'
+             */
+            endDate: string;
+            /**
+             * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
+             */
+            recurrence?: Array<string>;
+            /**
+             * Unique identifier for this time range
+             */
+            id: string;
+        }>;
+    };
+    errors?: Array<{
+        /**
+         * An identifier for the item that failed (e.g., event summary for creation, event ID for updates/cancellations)
+         */
+        identifier: string;
+        /**
+         * Description of the error that occurred
+         */
+        errorMessage: string;
+    }>;
+};
+/**
+ * Script input for the "Delete scheduling links." effect (`calendar.deleteSchedulingLinks`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * Delete scheduling links so they can no longer be booked. Existing meetings created from the links are not canceled.
+ */
+export type DeleteSchedulingLinksScriptInput = {
+    /**
+     * Scheduling links to delete
+     */
+    schedulingLinks: Array<{
+        /**
+         * ID of the scheduling link to delete
+         */
+        schedulingLinkId: string;
+        /**
+         * Current booking calendar for this scheduling link. Used to verify the link's existing calendar before deleting it.
+         */
+        bookingCalendarRef: {
+            /**
+             * Account that owns the current booking calendar.
+             */
+            accountId: string;
+            /**
+             * Current booking calendar identifier within the account.
+             */
+            calendarId: string;
+        };
+    }>;
+};
+/**
+ * Canonical Tool Core output for the "Delete scheduling links." effect (`calendar.deleteSchedulingLinks`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type DeleteSchedulingLinksScriptOutput = {
+    /**
+     * IDs of the scheduling links that were deleted
+     */
+    deletedSchedulingLinkIds: Array<string>;
+    errors?: Array<{
+        /**
+         * An identifier for the item that failed (e.g., event summary for creation, event ID for updates/cancellations)
+         */
+        identifier: string;
+        /**
+         * Description of the error that occurred
+         */
+        errorMessage: string;
+    }>;
+};
+/**
+ * Script input for the "List available calendar resources (such as conference rooms)." effect (`calendar.listCalendarResources`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * Search for resources (often conference rooms) and check their availability for specific time slots.
+ * Resources are scoped to a single account; pass `calendar` to target the account of the event you intend to attach the rooms to.
+ * Only works with Google Workspace accounts that have admin permissions to view calendar resources.
+ * Use this tool to find rooms when creating in-person meetings.
+ * Pass multiple meeting times in timeSlots to get available rooms for each time slot independently.
+ */
+export type ListCalendarResourcesScriptInput = {
+    /**
+     * Specific time slots to check. Returns available resources for each time slot independently.
+     */
+    timeSlots: Array<{
+        /**
+         * Start of the time slot to check, as an ISO 8601 date-time.
+         */
+        startAt: string;
+        /**
+         * End of the time slot to check, as an ISO 8601 date-time.
+         */
+        endAt: string;
+    }>;
+    /**
+     * Minimum room capacity (number of people). MUST include the meeting organizer/user themselves in the count. For a 1-on-1, pass 2. For a meeting with N invitees besides the user, pass N+1.
+     */
+    minCapacity: number;
+    /**
+     * Maximum number of resources to return per time slot (default: 20, max: 40)
+     */
+    maxCount?: number;
+    /**
+     * If true, do not narrow rooms to the user's working-location building for this day. Set this when the user is explicitly asking about rooms in a different office (e.g. for a visiting team).
+     */
+    ignoreWorkingLocation?: boolean;
+    /**
+     * Date-times of returned events will be expressed in this time-zone
+     */
+    timeZone: string;
+    /**
+     * Calendar of the event the rooms will be attached to. Rooms are scoped to a single account.
+     */
+    calendar?: {
+        /**
+         * Account that owns the target calendar.
+         */
+        accountId: string;
+        /**
+         * Target calendar identifier within the account.
+         */
+        calendarId: string;
+    };
+};
+/**
+ * Canonical Tool Core output for the "List available calendar resources (such as conference rooms)." effect (`calendar.listCalendarResources`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type ListCalendarResourcesScriptOutput = {
+    /**
+     * Results for each requested time slot, with available rooms sorted by capacity
+     */
+    resultsBySlot: Array<{
+        /**
+         * The time slot being checked
+         */
+        timeSlot: {
+            startAt: string;
+            endAt: string;
+        };
+        /**
+         * Available conference rooms for this time slot, sorted by increasing capacity (smallest rooms first)
+         */
+        availableResources: Array<{
+            /**
+             * Use this as the email when adding rooms to events
+             */
+            resourceEmail: string;
+            /**
+             * Display name of the conference room
+             */
+            resourceName: string;
+            /**
+             * Building information
+             */
+            building?: {
+                buildingId: string;
+                buildingName?: string;
+            };
+            /**
+             * Maximum number of people the room can accommodate
+             */
+            capacity?: number;
+            /**
+             * Floor location
+             */
+            floor?: string;
+            /**
+             * Room description
+             */
+            description?: string;
+        }>;
+    }>;
+};
+/**
+ * Script input for the "Fetch list of calendars of the user." effect (`calendar.listCalendars`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * List of calendars grouped by account.
+ */
+export type ListCalendarsScriptInput = {
+    /**
+     * Return only accounts linked to these email addresses. Useful to get calendars from a work account only for example. Do not specify if you are interested in getting the whole picture of someone's agenda across work and personal accounts.
+     */
+    onlyAccountEmails?: Array<string>;
+};
+/**
+ * Canonical Tool Core output for the "Fetch list of calendars of the user." effect (`calendar.listCalendars`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type ListCalendarsScriptOutput = {
+    accounts: Array<{
+        accountId: string;
+        /**
+         * Google, Apple iCloud, Outlook, etc.
+         */
+        providerName: string;
+        /**
+         * The user email associated with this account. Useful to know if this account and its data should be used depending on context.
+         */
+        email?: string;
+        /**
+         * Whether this account is work-related or a personal account, if we know this information.
+         */
+        category?: "work" | "personal";
+        capabilities: {
+            /**
+             * Does this account expose any calendars?
+             */
+            readCalendars: boolean;
+            /**
+             * Can we read calendar events from calendars of this account?
+             */
+            readEvents: boolean;
+            /**
+             * Can we write events in some calendars of this account? Calendars themselves might have their own set of restrictions.
+             */
+            writeEvents: boolean;
+            /**
+             * Can we use a text search query to find events in the calendars of this account?
+             */
+            searchEvents: boolean;
+            /**
+             * Does this account expose contacts?
+             */
+            readContacts: boolean;
+        };
+        /**
+         * User can access the events of co-workers having an email address with one of these domains
+         */
+        coworkersEmailDomains?: Array<string>;
+        calendars: Array<{
+            accountId: string;
+            calendarId: string;
+            name: string;
+            description?: string;
+            colors?: {
+                foreground?: string;
+                background?: string;
+            };
+            isPrimary: boolean;
+            /**
+             * Is this calendar read-only or can the user create/edit/delete events?
+             */
+            isReadOnly: boolean;
+            /**
+             * The contents of a calendar appear in the user calendar app only if that calendar is selected.
+             * Calendars that are not selected might be useful to get lower-signal events, but probably not to create events as it might not be visible to the user.
+             */
+            isSelected: boolean;
+            /**
+             * A hidden calendar is a calendar the user has access to but decided to hide completely from their calendar app.
+             * Hidden calendars might be useful to know what you might have access to, but keep in mind the user hid them and is most likely not aware of their content.
+             */
+            isHidden: boolean;
+            /**
+             * The email address of the owner of this calendar.
+             */
+            ownerEmail?: string;
+        }>;
+    }>;
+};
+/**
+ * Script input for the "List contacts" effect (`calendar.listContacts`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * List the user's contacts from different accounts. Returns contact information including email addresses, names, phone numbers, and profile photos.
+ */
+export type ListContactsScriptInput = {
+    /**
+     * Optional search queries to filter contacts by name or email. Results matching any query are included.
+     */
+    queries?: Array<string>;
+};
+/**
+ * Canonical Tool Core output for the "List contacts" effect (`calendar.listContacts`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type ListContactsScriptOutput = {
+    accounts: Array<{
+        accountId: string;
+        /**
+         * Google, Apple iCloud, Outlook, etc.
+         */
+        providerName: string;
+        /**
+         * The user email associated with this account. Useful to know if this account and its data should be used depending on context.
+         */
+        email?: string;
+        /**
+         * Whether this account is work-related or a personal account, if we know this information.
+         */
+        category?: "work" | "personal";
+        capabilities: {
+            /**
+             * Does this account expose any calendars?
+             */
+            readCalendars: boolean;
+            /**
+             * Can we read calendar events from calendars of this account?
+             */
+            readEvents: boolean;
+            /**
+             * Can we write events in some calendars of this account? Calendars themselves might have their own set of restrictions.
+             */
+            writeEvents: boolean;
+            /**
+             * Can we use a text search query to find events in the calendars of this account?
+             */
+            searchEvents: boolean;
+            /**
+             * Does this account expose contacts?
+             */
+            readContacts: boolean;
+        };
+        /**
+         * User can access the events of co-workers having an email address with one of these domains
+         */
+        coworkersEmailDomains?: Array<string>;
+        contacts: Array<{
+            /**
+             * Unique identifier for the contact
+             */
+            id: string;
+            /**
+             * Primary email address of the contact
+             */
+            email: string;
+            /**
+             * Additional email addresses for this contact
+             */
+            alternateEmails?: Array<string>;
+            /**
+             * Display name of the contact
+             */
+            displayName?: string;
+            /**
+             * Phone numbers associated with this contact
+             */
+            phoneNumbers?: Array<{
+                /**
+                 * The type of phone number (e.g., home, work, mobile)
+                 */
+                type?: string;
+                /**
+                 * The phone number value
+                 */
+                value: string;
+            }>;
+            /**
+             * URL to the contact's profile photo
+             */
+            photoUrl?: string;
+        }>;
+    }>;
+};
+/**
+ * Script input for the "View coworkers' scheduled events." effect (`calendar.listCoworkersEvents`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * Retrieves the detailed calendar events for specific coworkers within a time range.
+ * Use this to see what meetings or events people have scheduled, including event titles, times, and details.
+ * Only works for coworkers in the same organization domain.
+ */
+export type ListCoworkersEventsScriptInput = {
+    /**
+     * Emails of relevant coworkers
+     */
+    coworkerEmails: Array<string>;
+    /**
+     * Start of the time range, as an ISO 8601 date-time.
+     */
+    timeMin: string;
+    /**
+     * End of the time range, as an ISO 8601 date-time.
+     */
+    timeMax: string;
+    /**
+     * Date-times of returned events will be expressed in this time-zone
+     */
+    timeZone: string;
+};
+/**
+ * Canonical Tool Core output for the "View coworkers' scheduled events." effect (`calendar.listCoworkersEvents`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type ListCoworkersEventsScriptOutput = {
+    /**
+     * List of coworkers with their scheduled calendar events. Some coworkers may be excluded if their calendar could not be accessed.
+     */
+    coworkers: Array<{
+        accountId: string;
+        coworkerEmail: string;
+        profile?: {
+            displayName?: string;
+            email?: string;
+            photoUrl?: string;
+        };
+        events: Array<{
+            calendar: {
+                accountId: string;
+                calendarId: string;
+            };
+            eventId: string;
+            summary: string;
+            description?: string;
+            /**
+             * Physical location where the event takes place, or remote conference link/info.
+             */
+            location?: string;
+            /**
+             * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
+             */
+            recurrenceRules?: Array<string>;
+            /**
+             * The data provider this event belongs to
+             */
+            provider?: "google" | "notion" | "icloud" | "outlook";
+            /**
+             * The URL to view the event in the Calendar app.
+             */
+            webUrl: string;
+            /**
+             * When the event is happening
+             */
+            period: {
+                type: "DATE";
+                start: {
+                    /**
+                     * Date in ISO 8601 format (no time)
+                     */
+                    date: string;
+                };
+                end: {
+                    /**
+                     * Date in ISO 8601 format (no time)
+                     */
+                    date: string;
+                };
+            } | {
+                type: "DATE_TIME";
+                start: {
+                    /**
+                     * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
+                     */
+                    dateTime: string;
+                    timeZone?: string;
+                };
+                end: {
+                    /**
+                     * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
+                     */
+                    dateTime: string;
+                    timeZone?: string;
+                };
+            };
+            /**
+             * Whether it's part of a recurring event series
+             */
+            isRecurring: boolean;
+            /**
+             * If true, the event does not block time on the calendar. This is equivalent to setting `Show me as to Available` in the Calendar UI.
+             */
+            isTransparent: boolean;
+            /**
+             * Is the event an auto-blocking event created from another event? Used to create blocked events on a calendar from events on another calendar. You can ignore auto-blocked events if there are events happening at the exact same time on other calendars.
+             */
+            isAutoBlock: boolean;
+            /**
+             * What kind of event is it? Standard, out of office, birthday...
+             */
+            eventType?: "fromGmail" | "default" | "focusTime" | "outOfOffice" | "birthday" | "availability";
+            /**
+             * Is an event confirmed, tentative or cancelled? This is different from the user's RSVP
+             */
+            eventStatus?: "confirmed" | "tentative" | "cancelled";
+            /**
+             * Whether it's a meeting, aka an event with attendees listed
+             */
+            isMeeting: boolean;
+            conferencingEntryPoints?: Array<{
+                uri: string;
+                accessCode?: string;
+                entryPointType?: "video" | "phone" | "sip" | "more";
+                label?: string;
+                meetingCode?: string;
+                passcode?: string;
+                password?: string;
+                pin?: string;
+                notes?: string;
+                signature?: string;
+            }>;
+            /**
+             * The URL to join the video conference, if available
+             */
+            conferencingUrl?: string;
+            /**
+             * The calendar user's RSVP status
+             */
+            responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+            creator?: {
+                /**
+                 * Whether this entry represents the calendar user
+                 */
+                isSelf: boolean;
+                displayName?: string;
+                email?: string;
+            };
+            organizer?: {
+                /**
+                 * Whether this entry represents the calendar user
+                 */
+                isSelf: boolean;
+                displayName?: string;
+                email?: string;
+            };
+            attendees?: Array<{
+                /**
+                 * Whether this entry represents the calendar user
+                 */
+                isSelf: boolean;
+                displayName?: string;
+                email?: string;
+                isOptional: boolean;
+                isOrganizer?: boolean;
+                /**
+                 * The calendar user's RSVP status
+                 */
+                responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+            }>;
+            resources?: Array<{
+                displayName?: string;
+                email?: string;
+                isOptional: boolean;
+                /**
+                 * The calendar user's RSVP status
+                 */
+                responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+            }>;
+            colors?: {
+                foreground?: string;
+                background?: string;
+            };
+            attachments?: Array<{
+                url: string;
+                mimeType?: string;
+                title?: string;
+                notionWorkspaceId?: string;
+            }>;
+        }>;
+    }>;
+    errors?: Array<{
+        /**
+         * An identifier for the item that failed (e.g., event summary for creation, event ID for updates/cancellations)
+         */
+        identifier: string;
+        /**
+         * Description of the error that occurred
+         */
+        errorMessage: string;
+    }>;
+};
+/**
+ * Script input for the "List the user's events from different calendars." effect (`calendar.listEvents`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * Date-times will be expressed in the time-zone passed as parameter.
+ */
+export type ListEventsScriptInput = {
+    /**
+     * Start of the time range, as an ISO 8601 date-time.
+     */
+    timeMin: string;
+    /**
+     * End of the time range, as an ISO 8601 date-time.
+     */
+    timeMax: string;
+    /**
+     * Date-times of returned events will be expressed in this time-zone
+     */
+    timeZone: string;
+    /**
+     * Whether to include event invites the user has declined
+     */
+    includeDeclinedInvites?: boolean | null;
+};
+/**
+ * Canonical Tool Core output for the "List the user's events from different calendars." effect (`calendar.listEvents`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type ListEventsScriptOutput = {
+    accounts: Array<{
+        accountId: string;
+        /**
+         * Google, Apple iCloud, Outlook, etc.
+         */
+        providerName: string;
+        /**
+         * The user email associated with this account. Useful to know if this account and its data should be used depending on context.
+         */
+        email?: string;
+        /**
+         * Whether this account is work-related or a personal account, if we know this information.
+         */
+        category?: "work" | "personal";
+        capabilities: {
+            /**
+             * Does this account expose any calendars?
+             */
+            readCalendars: boolean;
+            /**
+             * Can we read calendar events from calendars of this account?
+             */
+            readEvents: boolean;
+            /**
+             * Can we write events in some calendars of this account? Calendars themselves might have their own set of restrictions.
+             */
+            writeEvents: boolean;
+            /**
+             * Can we use a text search query to find events in the calendars of this account?
+             */
+            searchEvents: boolean;
+            /**
+             * Does this account expose contacts?
+             */
+            readContacts: boolean;
+        };
+        /**
+         * User can access the events of co-workers having an email address with one of these domains
+         */
+        coworkersEmailDomains?: Array<string>;
+        calendars: Array<{
+            accountId: string;
+            calendarId: string;
+            name: string;
+            description?: string;
+            colors?: {
+                foreground?: string;
+                background?: string;
+            };
+            isPrimary: boolean;
+            /**
+             * Is this calendar read-only or can the user create/edit/delete events?
+             */
+            isReadOnly: boolean;
+            /**
+             * The contents of a calendar appear in the user calendar app only if that calendar is selected.
+             * Calendars that are not selected might be useful to get lower-signal events, but probably not to create events as it might not be visible to the user.
+             */
+            isSelected: boolean;
+            /**
+             * A hidden calendar is a calendar the user has access to but decided to hide completely from their calendar app.
+             * Hidden calendars might be useful to know what you might have access to, but keep in mind the user hid them and is most likely not aware of their content.
+             */
+            isHidden: boolean;
+            /**
+             * The email address of the owner of this calendar.
+             */
+            ownerEmail?: string;
+            events: Array<{
+                calendar: {
+                    accountId: string;
+                    calendarId: string;
+                };
+                eventId: string;
+                summary: string;
+                description?: string;
+                /**
+                 * Physical location where the event takes place, or remote conference link/info.
+                 */
+                location?: string;
+                /**
+                 * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
+                 */
+                recurrenceRules?: Array<string>;
+                /**
+                 * The data provider this event belongs to
+                 */
+                provider?: "google" | "notion" | "icloud" | "outlook";
+                /**
+                 * The URL to view the event in the Calendar app.
+                 */
+                webUrl: string;
+                /**
+                 * When the event is happening
+                 */
+                period: {
+                    type: "DATE";
+                    start: {
+                        /**
+                         * Date in ISO 8601 format (no time)
+                         */
+                        date: string;
+                    };
+                    end: {
+                        /**
+                         * Date in ISO 8601 format (no time)
+                         */
+                        date: string;
+                    };
+                } | {
+                    type: "DATE_TIME";
+                    start: {
+                        /**
+                         * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
+                         */
+                        dateTime: string;
+                        timeZone?: string;
+                    };
+                    end: {
+                        /**
+                         * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
+                         */
+                        dateTime: string;
+                        timeZone?: string;
+                    };
+                };
+                /**
+                 * Whether it's part of a recurring event series
+                 */
+                isRecurring: boolean;
+                /**
+                 * If true, the event does not block time on the calendar. This is equivalent to setting `Show me as to Available` in the Calendar UI.
+                 */
+                isTransparent: boolean;
+                /**
+                 * Is the event an auto-blocking event created from another event? Used to create blocked events on a calendar from events on another calendar. You can ignore auto-blocked events if there are events happening at the exact same time on other calendars.
+                 */
+                isAutoBlock: boolean;
+                /**
+                 * What kind of event is it? Standard, out of office, birthday...
+                 */
+                eventType?: "fromGmail" | "default" | "focusTime" | "outOfOffice" | "birthday" | "availability";
+                /**
+                 * Is an event confirmed, tentative or cancelled? This is different from the user's RSVP
+                 */
+                eventStatus?: "confirmed" | "tentative" | "cancelled";
+                /**
+                 * Whether it's a meeting, aka an event with attendees listed
+                 */
+                isMeeting: boolean;
+                conferencingEntryPoints?: Array<{
+                    uri: string;
+                    accessCode?: string;
+                    entryPointType?: "video" | "phone" | "sip" | "more";
+                    label?: string;
+                    meetingCode?: string;
+                    passcode?: string;
+                    password?: string;
+                    pin?: string;
+                    notes?: string;
+                    signature?: string;
+                }>;
                 /**
-                 * The phone number value
+                 * The URL to join the video conference, if available
                  */
-                value: string;
+                conferencingUrl?: string;
+                /**
+                 * The calendar user's RSVP status
+                 */
+                responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+                creator?: {
+                    /**
+                     * Whether this entry represents the calendar user
+                     */
+                    isSelf: boolean;
+                    displayName?: string;
+                    email?: string;
+                };
+                organizer?: {
+                    /**
+                     * Whether this entry represents the calendar user
+                     */
+                    isSelf: boolean;
+                    displayName?: string;
+                    email?: string;
+                };
+                attendees?: Array<{
+                    /**
+                     * Whether this entry represents the calendar user
+                     */
+                    isSelf: boolean;
+                    displayName?: string;
+                    email?: string;
+                    isOptional: boolean;
+                    isOrganizer?: boolean;
+                    /**
+                     * The calendar user's RSVP status
+                     */
+                    responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+                }>;
+                resources?: Array<{
+                    displayName?: string;
+                    email?: string;
+                    isOptional: boolean;
+                    /**
+                     * The calendar user's RSVP status
+                     */
+                    responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+                }>;
+                colors?: {
+                    foreground?: string;
+                    background?: string;
+                };
+                attachments?: Array<{
+                    url: string;
+                    mimeType?: string;
+                    title?: string;
+                    notionWorkspaceId?: string;
+                }>;
             }>;
+        }>;
+    }>;
+    /**
+     * User preferences for calendar data
+     */
+    userPreferences: {
+        /**
+         * Whether the user prefers to display time in 12-hour (AM/PM) or 24-hour format
+         */
+        timeFormat?: "12_HOUR" | "24_HOUR";
+    };
+    errors: Array<{
+        accountId: string;
+        calendarId: string;
+        error: string;
+    }>;
+};
+/**
+ * Script input for the "List the user's scheduling links." effect (`calendar.listSchedulingLinks`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * List active, unexpired scheduling links with upcoming time ranges, optionally filtered by link type.
+ */
+export type ListSchedulingLinksScriptInput = {
+    /**
+     * Return only scheduling links of this type
+     */
+    type?: "singleUse" | "multiUse" | "recurring";
+};
+/**
+ * Canonical Tool Core output for the "List the user's scheduling links." effect (`calendar.listSchedulingLinks`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type ListSchedulingLinksScriptOutput = {
+    schedulingLinks: Array<{
+        /**
+         * Unique ID of the created scheduling link
+         */
+        id: string;
+        /**
+         * Short ID used in the scheduling link URL
+         */
+        shortId: string;
+        /**
+         * Current booking calendar for this scheduling link
+         */
+        bookingCalendarRef: {
+            accountId: string;
+            calendarId: string;
+        };
+        /**
+         * Custom URL slug for the scheduling link
+         */
+        alias?: string;
+        /**
+         * The resolved type of the link
+         */
+        type?: "singleUse" | "multiUse" | "recurring";
+        /**
+         * Status of the scheduling link
+         */
+        status: string;
+        title?: string;
+        description?: string;
+        duration?: number;
+        /**
+         * Full URL where invitees can book a meeting
+         */
+        schedulingLinkUrl?: string;
+        timeRanges: Array<{
             /**
-             * URL to the contact's profile photo
+             * Start of availability window in ISO 8601 format with timezone offset, e.g. '2024-08-22T09:00:00-04:00'
              */
-            photoUrl?: string;
+            startDate: string;
+            /**
+             * End of availability window in ISO 8601 format with timezone offset, e.g. '2024-08-22T17:00:00-04:00'
+             */
+            endDate: string;
+            /**
+             * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
+             */
+            recurrence?: Array<string>;
+            /**
+             * Unique identifier for this time range
+             */
+            id: string;
+        }>;
+    }>;
+};
+/**
+ * Script input for the "Find available meeting times." effect (`calendar.suggestMeetingTimes`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * Analyzes calendar availability for multiple participants and returns ranked time slots when everyone is free.
+ * Use this when scheduling meetings or finding times that work for a group of people.
+ * Returns suggestions sorted by preference, showing which participants are available, softly conflicted by an unconfirmed RSVP, busy, or have unknown status for each slot.
+ */
+export type SuggestMeetingTimesScriptInput = {
+    /**
+     * Individual participant or group email addresses to find time with. Resolvable groups are expanded into their members.
+     */
+    participantEmails: Array<string>;
+    /**
+     * The duration of the meeting in minutes
+     */
+    durationMinutes: number;
+    /**
+     * Start of the time range to consider, as an ISO 8601 date-time.
+     */
+    timeMin: string;
+    /**
+     * End of the time range to consider, as an ISO 8601 date-time.
+     */
+    timeMax: string;
+    /**
+     * Maximum number of suggestions to return (default: 10)
+     */
+    maxCount?: number;
+    /**
+     * Date-times of returned events will be expressed in this time-zone
+     */
+    timeZone: string;
+    /**
+     * Whether to include participant event schedules in the response
+     */
+    includeParticipantSchedules?: boolean;
+};
+/**
+ * Canonical Tool Core output for the "Find available meeting times." effect (`calendar.suggestMeetingTimes`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type SuggestMeetingTimesScriptOutput = {
+    /**
+     * Ranked list of available meeting time slots, sorted from most to least preferable. Each slot includes start/end times and categorizes participants by availability status.
+     */
+    suggestions: Array<{
+        /**
+         * Start time in ISO 8601 format
+         */
+        startAt: string;
+        /**
+         * End time in ISO 8601 format
+         */
+        endAt: string;
+        /**
+         * Total number of hard event conflicts, including multiple events for one participant
+         */
+        hardEventConflictCount: number;
+        /**
+         * Total number of soft event conflicts, including multiple events for one participant
+         */
+        softEventConflictCount: number;
+        /**
+         * Participant emails for invitees with conflicts with this meeting time
+         */
+        unavailableParticipants: Array<string>;
+        /**
+         * Participant emails for invitees who are available for this meeting time
+         */
+        availableParticipants: Array<string>;
+        /**
+         * Participant emails for invitees with overlapping events whose RSVP is not firm yet
+         */
+        softConflictParticipants: Array<string>;
+        /**
+         * Participant emails for invitees with unknown status
+         */
+        unknownStatus: Array<string>;
+        /**
+         * Readable participant events that overlap this meeting time, including the participant and whether each event creates a hard or soft conflict
+         */
+        conflictingEvents: Array<{
+            participantEmail: string;
+            eventId: string;
+            summary?: string;
+            /**
+             * What kind of event is it? Standard, out of office, birthday...
+             */
+            eventType: "fromGmail" | "default" | "focusTime" | "outOfOffice" | "birthday" | "availability";
+            /**
+             * The calendar user's RSVP status
+             */
+            responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+            conflictType: "hard" | "soft";
         }>;
     }>;
-};
-/**
- * Script input for the "View coworkers' scheduled events." effect (`calendar.listCoworkersEvents`),
- * derived from its Tool Core definition's call_function input projection.
- *
- * Retrieves the detailed calendar events for specific coworkers within a time range.
- * Use this to see what meetings or events people have scheduled, including event titles, times, and details.
- * Only works for coworkers in the same organization domain.
- */
-export type ListCoworkersEventsScriptInput = {
-    /**
-     * Emails of relevant coworkers
-     */
-    coworkerEmails: Array<string>;
-    /**
-     * Start of the time range, as an ISO 8601 date-time.
-     */
-    timeMin: string;
-    /**
-     * End of the time range, as an ISO 8601 date-time.
-     */
-    timeMax: string;
     /**
-     * Date-times of returned events will be expressed in this time-zone
+     * Whether one or more suggestions use a shorter duration than requested because no sufficiently conflict-free times were available at the requested duration
      */
-    timeZone: string;
-};
-/**
- * Canonical Tool Core output for the "View coworkers' scheduled events." effect (`calendar.listCoworkersEvents`).
- * This is the definition's output schema; the effect's script surface may
- * re-encode it before returning.
- */
-export type ListCoworkersEventsScriptOutput = {
+    usedFlexibleDuration: boolean;
     /**
-     * List of coworkers with their scheduled calendar events. Some coworkers may be excluded if their calendar could not be accessed.
+     * List of participant schedules, one for each individual participant, including resolved group members. Each schedule includes basic participant information and a list of the participant's calendar events.
      */
-    coworkers: Array<{
+    participantSchedules?: Array<{
         accountId: string;
         coworkerEmail: string;
         profile?: {
@@ -332,29 +1605,16 @@ export type ListCoworkersEventsScriptOutput = {
             photoUrl?: string;
         };
         events: Array<{
-            calendar: {
-                accountId: string;
-                calendarId: string;
-            };
             eventId: string;
-            summary: string;
-            description?: string;
-            /**
-             * Physical location where the event takes place, or remote conference link/info.
-             */
-            location?: string;
             /**
-             * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
-             */
-            recurrenceRules?: Array<string>;
-            /**
-             * The data provider this event belongs to
+             * What kind of event is it? Standard, out of office, birthday...
              */
-            provider?: "google" | "notion" | "icloud" | "outlook";
+            eventType?: "fromGmail" | "default" | "focusTime" | "outOfOffice" | "birthday" | "availability";
             /**
-             * The URL to view the event in the Calendar app.
+             * Is an event confirmed, tentative or cancelled? This is different from the user's RSVP
              */
-            webUrl: string;
+            eventStatus?: "confirmed" | "tentative" | "cancelled";
+            summary: string;
             /**
              * When the event is happening
              */
@@ -390,98 +1650,21 @@ export type ListCoworkersEventsScriptOutput = {
                 };
             };
             /**
-             * Whether it's part of a recurring event series
+             * The calendar user's RSVP status
              */
-            isRecurring: boolean;
+            responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+            colors?: {
+                foreground?: string;
+                background?: string;
+            };
             /**
              * If true, the event does not block time on the calendar. This is equivalent to setting `Show me as to Available` in the Calendar UI.
              */
             isTransparent: boolean;
-            /**
-             * Is the event an auto-blocking event created from another event? Used to create blocked events on a calendar from events on another calendar. You can ignore auto-blocked events if there are events happening at the exact same time on other calendars.
-             */
-            isAutoBlock: boolean;
-            /**
-             * What kind of event is it? Standard, out of office, birthday...
-             */
-            eventType?: "fromGmail" | "default" | "focusTime" | "outOfOffice" | "birthday" | "availability";
-            /**
-             * Is an event confirmed, tentative or cancelled? This is different from the user's RSVP
-             */
-            eventStatus?: "confirmed" | "tentative" | "cancelled";
             /**
              * Whether it's a meeting, aka an event with attendees listed
              */
             isMeeting: boolean;
-            conferencingEntryPoints?: Array<{
-                uri: string;
-                accessCode?: string;
-                entryPointType?: "video" | "phone" | "sip" | "more";
-                label?: string;
-                meetingCode?: string;
-                passcode?: string;
-                password?: string;
-                pin?: string;
-                notes?: string;
-                signature?: string;
-            }>;
-            /**
-             * The URL to join the video conference, if available
-             */
-            conferencingUrl?: string;
-            /**
-             * The calendar user's RSVP status
-             */
-            responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
-            creator?: {
-                /**
-                 * Whether this entry represents the calendar user
-                 */
-                isSelf: boolean;
-                displayName?: string;
-                email?: string;
-            };
-            organizer?: {
-                /**
-                 * Whether this entry represents the calendar user
-                 */
-                isSelf: boolean;
-                displayName?: string;
-                email?: string;
-            };
-            attendees?: Array<{
-                /**
-                 * Whether this entry represents the calendar user
-                 */
-                isSelf: boolean;
-                displayName?: string;
-                email?: string;
-                isOptional: boolean;
-                isOrganizer?: boolean;
-                /**
-                 * The calendar user's RSVP status
-                 */
-                responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
-            }>;
-            resources?: Array<{
-                displayName?: string;
-                email?: string;
-                isOptional: boolean;
-                /**
-                 * The calendar user's RSVP status
-                 */
-                responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
-            }>;
-            colors?: {
-                foreground?: string;
-                background?: string;
-            };
-            attachments?: Array<{
-                url: string;
-                mimeType?: string;
-                title?: string;
-                notionWorkspaceId?: string;
-            }>;
         }>;
     }>;
     errors?: Array<{
@@ -496,326 +1679,458 @@ export type ListCoworkersEventsScriptOutput = {
     }>;
 };
 /**
- * Script input for the "List the user's events from different calendars." effect (`calendar.listEvents`),
+ * Script input for the "Update calendar events." effect (`calendar.updateEvents`),
  * derived from its Tool Core definition's call_function input projection.
  *
- * Date-times will be expressed in the time-zone passed as parameter.
+ * If the event has an organizer and it's not the user, then only RSVP changes are always allowed. Some participant events may also allow updates when guests can invite others.
+ * If the event has attendees, they will receive a notification of the changes.
  */
-export type ListEventsScriptInput = {
-    /**
-     * Start of the time range, as an ISO 8601 date-time.
-     */
-    timeMin: string;
-    /**
-     * End of the time range, as an ISO 8601 date-time.
-     */
-    timeMax: string;
+export type UpdateEventsScriptInput = {
     /**
      * Date-times of returned events will be expressed in this time-zone
      */
     timeZone: string;
     /**
-     * Whether to include event invites the user has declined
+     * Event updates to apply.
      */
-    includeDeclinedInvites?: boolean | null;
-};
-/**
- * Canonical Tool Core output for the "List the user's events from different calendars." effect (`calendar.listEvents`).
- * This is the definition's output schema; the effect's script surface may
- * re-encode it before returning.
- */
-export type ListEventsScriptOutput = {
-    accounts: Array<{
-        accountId: string;
-        /**
-         * Google, Apple iCloud, Outlook, etc.
-         */
-        providerName: string;
+    updates: Array<{
         /**
-         * The user email associated with this account. Useful to know if this account and its data should be used depending on context.
+         * Must be set to the exact string "RSVP" in upper case.
          */
-        email?: string;
+        updateType: "RSVP";
         /**
-         * Whether this account is work-related or a personal account, if we know this information.
+         * Event to update.
          */
-        category?: "work" | "personal";
-        capabilities: {
+        event: {
             /**
-             * Does this account expose any calendars?
+             * Calendar containing the event.
              */
-            readCalendars: boolean;
+            calendar: {
+                /**
+                 * Account that owns the event calendar.
+                 */
+                accountId: string;
+                /**
+                 * Event calendar identifier within the account.
+                 */
+                calendarId: string;
+            };
             /**
-             * Can we read calendar events from calendars of this account?
+             * Identifier of the event to update.
              */
-            readEvents: boolean;
+            eventId: string;
             /**
-             * Can we write events in some calendars of this account? Calendars themselves might have their own set of restrictions.
+             * Optional summary of the event, used by agent UI.
              */
-            writeEvents: boolean;
+            eventSummary?: string;
+        };
+        /**
+         * RSVP update to apply to the event.
+         */
+        rsvp: {
             /**
-             * Can we use a text search query to find events in the calendars of this account?
+             * The calendar user's RSVP status
              */
-            searchEvents: boolean;
+            responseStatus: "needsAction" | "accepted" | "declined" | "tentative";
             /**
-             * Does this account expose contacts?
+             * Optional comment accompanying the RSVP.
              */
-            readContacts: boolean;
+            comment?: string;
         };
+    } | {
         /**
-         * User can access the events of co-workers having an email address with one of these domains
+         * Must be set to the exact string "UPDATE" in upper case.
          */
-        coworkersEmailDomains?: Array<string>;
-        calendars: Array<{
-            accountId: string;
-            calendarId: string;
-            name: string;
-            description?: string;
-            colors?: {
-                foreground?: string;
-                background?: string;
+        updateType: "UPDATE";
+        /**
+         * Event to update.
+         */
+        event: {
+            /**
+             * Calendar containing the event.
+             */
+            calendar: {
+                /**
+                 * Account that owns the event calendar.
+                 */
+                accountId: string;
+                /**
+                 * Event calendar identifier within the account.
+                 */
+                calendarId: string;
             };
-            isPrimary: boolean;
             /**
-             * Is this calendar read-only or can the user create/edit/delete events?
+             * Identifier of the event to update.
              */
-            isReadOnly: boolean;
+            eventId: string;
             /**
-             * The contents of a calendar appear in the user calendar app only if that calendar is selected.
-             * Calendars that are not selected might be useful to get lower-signal events, but probably not to create events as it might not be visible to the user.
+             * Optional summary of the event, used by agent UI.
              */
-            isSelected: boolean;
+            eventSummary?: string;
+        };
+        /**
+         * Changes to apply to the event.
+         */
+        update: {
             /**
-             * A hidden calendar is a calendar the user has access to but decided to hide completely from their calendar app.
-             * Hidden calendars might be useful to know what you might have access to, but keep in mind the user hid them and is most likely not aware of their content.
+             * Updated title of the event.
              */
-            isHidden: boolean;
+            summary?: string;
             /**
-             * The email address of the owner of this calendar.
+             * Updated description of the event.
              */
-            ownerEmail?: string;
-            events: Array<{
-                calendar: {
-                    accountId: string;
-                    calendarId: string;
-                };
-                eventId: string;
-                summary: string;
-                description?: string;
+            description?: string;
+            /**
+             * Physical location where the event takes place, or remote conference link/info.
+             */
+            location?: string;
+            /**
+             * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
+             */
+            recurrenceRules?: Array<string>;
+            /**
+             * When the event is happening
+             */
+            period?: {
                 /**
-                 * Physical location where the event takes place, or remote conference link/info.
+                 * Whether the updated event period uses all-day dates or date-times.
                  */
-                location?: string;
+                type: "DATE";
                 /**
-                 * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
+                 * Updated start of the event.
                  */
-                recurrenceRules?: Array<string>;
+                start: {
+                    /**
+                     * Date in ISO 8601 format (no time)
+                     */
+                    date: string;
+                };
                 /**
-                 * The data provider this event belongs to
+                 * Updated end of the event.
                  */
-                provider?: "google" | "notion" | "icloud" | "outlook";
+                end: {
+                    /**
+                     * Date in ISO 8601 format (no time)
+                     */
+                    date: string;
+                };
+            } | {
                 /**
-                 * The URL to view the event in the Calendar app.
+                 * Whether the updated event period uses all-day dates or date-times.
                  */
-                webUrl: string;
+                type: "DATE_TIME";
                 /**
-                 * When the event is happening
+                 * Updated start of the event.
                  */
-                period: {
-                    type: "DATE";
-                    start: {
-                        /**
-                         * Date in ISO 8601 format (no time)
-                         */
-                        date: string;
-                    };
-                    end: {
-                        /**
-                         * Date in ISO 8601 format (no time)
-                         */
-                        date: string;
-                    };
-                } | {
-                    type: "DATE_TIME";
-                    start: {
-                        /**
-                         * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
-                         */
-                        dateTime: string;
-                        timeZone?: string;
-                    };
-                    end: {
-                        /**
-                         * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
-                         */
-                        dateTime: string;
-                        timeZone?: string;
-                    };
+                start: {
+                    /**
+                     * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset, or without TZ offset if `timeZone` is specified in which case will be interpreted as local time in that timeZone
+                     */
+                    dateTime: string;
+                    /**
+                     * IANA time zone for the updated event start date-time.
+                     */
+                    timeZone?: string;
                 };
                 /**
-                 * Whether it's part of a recurring event series
+                 * Updated end of the event.
                  */
-                isRecurring: boolean;
+                end: {
+                    /**
+                     * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset, or without TZ offset if `timeZone` is specified in which case will be interpreted as local time in that timeZone
+                     */
+                    dateTime: string;
+                    /**
+                     * IANA time zone for the updated event end date-time.
+                     */
+                    timeZone?: string;
+                };
+            };
+            /**
+             * Updated list of attendees for the event
+             */
+            attendees?: Array<{
                 /**
-                 * If true, the event does not block time on the calendar. This is equivalent to setting `Show me as to Available` in the Calendar UI.
+                 * Email address of the attendee.
                  */
-                isTransparent: boolean;
+                email: string;
                 /**
-                 * Is the event an auto-blocking event created from another event? Used to create blocked events on a calendar from events on another calendar. You can ignore auto-blocked events if there are events happening at the exact same time on other calendars.
+                 * Totally optional, provide only if you are sure of the attendee's name
                  */
-                isAutoBlock: boolean;
+                displayName?: string;
                 /**
-                 * What kind of event is it? Standard, out of office, birthday...
+                 * Set only if the user was explicit about an attendee not being required
                  */
-                eventType?: "fromGmail" | "default" | "focusTime" | "outOfOffice" | "birthday" | "availability";
+                isOptional?: boolean;
+            }>;
+            /**
+             * Updated list of resources (such as rooms) for the event. Must be from the same account as `event.calendar`.
+             */
+            resources?: Array<{
                 /**
-                 * Is an event confirmed, tentative or cancelled? This is different from the user's RSVP
+                 * Email address of the resource.
                  */
-                eventStatus?: "confirmed" | "tentative" | "cancelled";
+                email?: string;
                 /**
-                 * Whether it's a meeting, aka an event with attendees listed
+                 * Display name of the resource.
                  */
-                isMeeting: boolean;
-                conferencingEntryPoints?: Array<{
-                    uri: string;
-                    accessCode?: string;
-                    entryPointType?: "video" | "phone" | "sip" | "more";
-                    label?: string;
-                    meetingCode?: string;
-                    passcode?: string;
-                    password?: string;
-                    pin?: string;
-                    notes?: string;
-                    signature?: string;
-                }>;
+                displayName?: string;
                 /**
-                 * The URL to join the video conference, if available
+                 * Set only if the user was explicit about a resource not being required
                  */
-                conferencingUrl?: string;
+                isOptional: boolean;
+            }>;
+            /**
+             * Whether to add conferencing to this event. Only adds conferencing if the event has attendees and doesn't already have conferencing.
+             */
+            addConferencing?: boolean;
+        };
+    }>;
+};
+/**
+ * Canonical Tool Core output for the "Update calendar events." effect (`calendar.updateEvents`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type UpdateEventsScriptOutput = {
+    updatedEvents: Array<{
+        calendar: {
+            accountId: string;
+            calendarId: string;
+        };
+        eventId: string;
+        summary: string;
+        description?: string;
+        /**
+         * Physical location where the event takes place, or remote conference link/info.
+         */
+        location?: string;
+        /**
+         * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
+         */
+        recurrenceRules?: Array<string>;
+        /**
+         * The data provider this event belongs to
+         */
+        provider?: "google" | "notion" | "icloud" | "outlook";
+        /**
+         * The URL to view the event in the Calendar app.
+         */
+        webUrl: string;
+        /**
+         * When the event is happening
+         */
+        period: {
+            type: "DATE";
+            start: {
                 /**
-                 * The calendar user's RSVP status
+                 * Date in ISO 8601 format (no time)
                  */
-                responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
-                creator?: {
-                    /**
-                     * Whether this entry represents the calendar user
-                     */
-                    isSelf: boolean;
-                    displayName?: string;
-                    email?: string;
-                };
-                organizer?: {
-                    /**
-                     * Whether this entry represents the calendar user
-                     */
-                    isSelf: boolean;
-                    displayName?: string;
-                    email?: string;
-                };
-                attendees?: Array<{
-                    /**
-                     * Whether this entry represents the calendar user
-                     */
-                    isSelf: boolean;
-                    displayName?: string;
-                    email?: string;
-                    isOptional: boolean;
-                    isOrganizer?: boolean;
-                    /**
-                     * The calendar user's RSVP status
-                     */
-                    responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
-                }>;
-                resources?: Array<{
-                    displayName?: string;
-                    email?: string;
-                    isOptional: boolean;
-                    /**
-                     * The calendar user's RSVP status
-                     */
-                    responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
-                }>;
-                colors?: {
-                    foreground?: string;
-                    background?: string;
-                };
-                attachments?: Array<{
-                    url: string;
-                    mimeType?: string;
-                    title?: string;
-                    notionWorkspaceId?: string;
-                }>;
-            }>;
+                date: string;
+            };
+            end: {
+                /**
+                 * Date in ISO 8601 format (no time)
+                 */
+                date: string;
+            };
+        } | {
+            type: "DATE_TIME";
+            start: {
+                /**
+                 * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
+                 */
+                dateTime: string;
+                timeZone?: string;
+            };
+            end: {
+                /**
+                 * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
+                 */
+                dateTime: string;
+                timeZone?: string;
+            };
+        };
+        /**
+         * Whether it's part of a recurring event series
+         */
+        isRecurring: boolean;
+        /**
+         * If true, the event does not block time on the calendar. This is equivalent to setting `Show me as to Available` in the Calendar UI.
+         */
+        isTransparent: boolean;
+        /**
+         * Is the event an auto-blocking event created from another event? Used to create blocked events on a calendar from events on another calendar. You can ignore auto-blocked events if there are events happening at the exact same time on other calendars.
+         */
+        isAutoBlock: boolean;
+        /**
+         * What kind of event is it? Standard, out of office, birthday...
+         */
+        eventType?: "fromGmail" | "default" | "focusTime" | "outOfOffice" | "birthday" | "availability";
+        /**
+         * Is an event confirmed, tentative or cancelled? This is different from the user's RSVP
+         */
+        eventStatus?: "confirmed" | "tentative" | "cancelled";
+        /**
+         * Whether it's a meeting, aka an event with attendees listed
+         */
+        isMeeting: boolean;
+        conferencingEntryPoints?: Array<{
+            uri: string;
+            accessCode?: string;
+            entryPointType?: "video" | "phone" | "sip" | "more";
+            label?: string;
+            meetingCode?: string;
+            passcode?: string;
+            password?: string;
+            pin?: string;
+            notes?: string;
+            signature?: string;
+        }>;
+        /**
+         * The URL to join the video conference, if available
+         */
+        conferencingUrl?: string;
+        /**
+         * The calendar user's RSVP status
+         */
+        responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+        creator?: {
+            /**
+             * Whether this entry represents the calendar user
+             */
+            isSelf: boolean;
+            displayName?: string;
+            email?: string;
+        };
+        organizer?: {
+            /**
+             * Whether this entry represents the calendar user
+             */
+            isSelf: boolean;
+            displayName?: string;
+            email?: string;
+        };
+        attendees?: Array<{
+            /**
+             * Whether this entry represents the calendar user
+             */
+            isSelf: boolean;
+            displayName?: string;
+            email?: string;
+            isOptional: boolean;
+            isOrganizer?: boolean;
+            /**
+             * The calendar user's RSVP status
+             */
+            responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+        }>;
+        resources?: Array<{
+            displayName?: string;
+            email?: string;
+            isOptional: boolean;
+            /**
+             * The calendar user's RSVP status
+             */
+            responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
+        }>;
+        colors?: {
+            foreground?: string;
+            background?: string;
+        };
+        attachments?: Array<{
+            url: string;
+            mimeType?: string;
+            title?: string;
+            notionWorkspaceId?: string;
         }>;
     }>;
-    /**
-     * User preferences for calendar data
-     */
-    userPreferences: {
+    errors?: Array<{
         /**
-         * Whether the user prefers to display time in 12-hour (AM/PM) or 24-hour format
+         * An identifier for the item that failed (e.g., event summary for creation, event ID for updates/cancellations)
          */
-        timeFormat?: "12_HOUR" | "24_HOUR";
-    };
-    errors: Array<{
-        accountId: string;
-        calendarId: string;
-        error: string;
+        identifier: string;
+        /**
+         * Description of the error that occurred
+         */
+        errorMessage: string;
     }>;
 };
 /**
- * Script input for the "List the user's scheduling links." effect (`calendar.listSchedulingLinks`),
+ * Script input for the "Update a scheduling link." effect (`calendar.updateSchedulingLink`),
  * derived from its Tool Core definition's call_function input projection.
  *
- * List active, unexpired scheduling links with upcoming time ranges, optionally filtered by link type.
+ * Update an existing active scheduling link by providing its current identity and a patch of requested changes. Omitted patch fields are left unchanged, and nullable patch fields can be cleared with null.
  */
-export type ListSchedulingLinksScriptInput = {
+export type UpdateSchedulingLinkScriptInput = {
     /**
-     * Return only scheduling links of this type
+     * Identity of the scheduling link to update. These fields are used only to select and guard the existing link.
      */
-    type?: "singleUse" | "multiUse" | "recurring";
-};
-/**
- * Canonical Tool Core output for the "List the user's scheduling links." effect (`calendar.listSchedulingLinks`).
- * This is the definition's output schema; the effect's script surface may
- * re-encode it before returning.
- */
-export type ListSchedulingLinksScriptOutput = {
-    schedulingLinks: Array<{
+    identity: {
         /**
-         * Unique ID of the created scheduling link
+         * ID of the scheduling link to update
          */
-        id: string;
+        schedulingLinkId: string;
         /**
-         * Short ID used in the scheduling link URL
+         * Current booking calendar for this scheduling link. Used to verify that the agent is updating the intended link.
          */
-        shortId: string;
+        bookingCalendarRef: {
+            /**
+             * Account that owns the current booking calendar.
+             */
+            accountId: string;
+            /**
+             * Current booking calendar identifier within the account.
+             */
+            calendarId: string;
+        };
+    };
+    /**
+     * Patch of changes to apply to the scheduling link. Omitted fields are left unchanged, and nullable fields can be cleared with null.
+     */
+    patch?: {
         /**
-         * Current booking calendar for this scheduling link
+         * Replace the calendar where meetings booked through this scheduling link are created
          */
-        bookingCalendarRef: {
+        bookingCalendar?: {
+            /**
+             * Account that owns the replacement booking calendar.
+             */
             accountId: string;
+            /**
+             * Replacement booking calendar identifier within the account.
+             */
             calendarId: string;
         };
         /**
-         * Custom URL slug for the scheduling link
+         * Replace the calendars checked for conflicts when determining availability
          */
-        alias?: string;
+        conflictCalendars?: Array<{
+            /**
+             * Account that owns the replacement conflict calendar.
+             */
+            accountId: string;
+            /**
+             * Replacement conflict calendar identifier within the account.
+             */
+            calendarId: string;
+        }>;
         /**
-         * The resolved type of the link
+         * Update the scheduling link title. Use null to clear it.
          */
-        type?: "singleUse" | "multiUse" | "recurring";
+        title?: string | null;
         /**
-         * Status of the scheduling link
+         * Update the scheduling link description. Use null to clear it.
+         */
+        description?: string | null;
+        /**
+         * Update the meeting duration in minutes
          */
-        status: string;
-        title?: string;
-        description?: string;
         duration?: number;
         /**
-         * Full URL where invitees can book a meeting
+         * Replace the scheduling link availability windows
          */
-        schedulingLinkUrl?: string;
-        timeRanges: Array<{
+        timeRanges?: Array<{
             /**
              * Start of availability window in ISO 8601 format with timezone offset, e.g. '2024-08-22T09:00:00-04:00'
              */
@@ -828,189 +2143,96 @@ export type ListSchedulingLinksScriptOutput = {
              * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
              */
             recurrence?: Array<string>;
-            /**
-             * Unique identifier for this time range
-             */
-            id: string;
         }>;
-    }>;
-};
-/**
- * Script input for the "Find available meeting times." effect (`calendar.suggestMeetingTimes`),
- * derived from its Tool Core definition's call_function input projection.
- *
- * Analyzes calendar availability for multiple participants and returns ranked time slots when everyone is free.
- * Use this when scheduling meetings or finding times that work for a group of people.
- * Returns suggestions sorted by preference, showing which participants are available, softly conflicted by an unconfirmed RSVP, busy, or have unknown status for each slot.
- */
-export type SuggestMeetingTimesScriptInput = {
-    /**
-     * Individual participant or group email addresses to find time with. Resolvable groups are expanded into their members.
-     */
-    participantEmails: Array<string>;
-    /**
-     * The duration of the meeting in minutes
-     */
-    durationMinutes: number;
-    /**
-     * Start of the time range to consider, as an ISO 8601 date-time.
-     */
-    timeMin: string;
-    /**
-     * End of the time range to consider, as an ISO 8601 date-time.
-     */
-    timeMax: string;
-    /**
-     * Maximum number of suggestions to return (default: 10)
-     */
-    maxCount?: number;
-    /**
-     * Date-times of returned events will be expressed in this time-zone
-     */
-    timeZone: string;
-    /**
-     * Whether to include participant event schedules in the response
-     */
-    includeParticipantSchedules?: boolean;
+        /**
+         * Update the scheduling link type. If omitted while timeRanges are updated, the type is inferred from the new timeRanges.
+         */
+        type?: "singleUse" | "multiUse" | "recurring";
+        /**
+         * Update the custom URL slug for the scheduling link. Must be between 1 and 32 characters.
+         */
+        alias?: string;
+        /**
+         * If true, apply the default conferencing for the effective booking calendar account. If false, clear conferencing.
+         */
+        useDefaultConferencing?: boolean;
+        /**
+         * Update the minimum lead time in minutes. Must be 0 or greater and less than maxLeadTime when both are set. Use null to clear it.
+         */
+        minLeadTime?: number | null;
+        /**
+         * Update the maximum lead time in minutes. Must be greater than 0 and greater than minLeadTime when both are set. Use null to clear it.
+         */
+        maxLeadTime?: number | null;
+        /**
+         * Update the expiration date for the scheduling link. Must be in the future when provided. Use null to clear it.
+         */
+        expirationDate?: string | null;
+    };
 };
 /**
- * Canonical Tool Core output for the "Find available meeting times." effect (`calendar.suggestMeetingTimes`).
+ * Canonical Tool Core output for the "Update a scheduling link." effect (`calendar.updateSchedulingLink`).
  * This is the definition's output schema; the effect's script surface may
  * re-encode it before returning.
  */
-export type SuggestMeetingTimesScriptOutput = {
+export type UpdateSchedulingLinkScriptOutput = {
     /**
-     * Ranked list of available meeting time slots, sorted from most to least preferable. Each slot includes start/end times and categorizes participants by availability status.
+     * The updated scheduling link
      */
-    suggestions: Array<{
-        /**
-         * Start time in ISO 8601 format
-         */
-        startAt: string;
-        /**
-         * End time in ISO 8601 format
-         */
-        endAt: string;
+    schedulingLink?: {
         /**
-         * Total number of hard event conflicts, including multiple events for one participant
+         * Unique ID of the created scheduling link
          */
-        hardEventConflictCount: number;
+        id: string;
         /**
-         * Total number of soft event conflicts, including multiple events for one participant
+         * Short ID used in the scheduling link URL
          */
-        softEventConflictCount: number;
+        shortId: string;
         /**
-         * Participant emails for invitees with conflicts with this meeting time
+         * Current booking calendar for this scheduling link
          */
-        unavailableParticipants: Array<string>;
+        bookingCalendarRef: {
+            accountId: string;
+            calendarId: string;
+        };
         /**
-         * Participant emails for invitees who are available for this meeting time
+         * Custom URL slug for the scheduling link
          */
-        availableParticipants: Array<string>;
+        alias?: string;
         /**
-         * Participant emails for invitees with overlapping events whose RSVP is not firm yet
+         * The resolved type of the link
          */
-        softConflictParticipants: Array<string>;
+        type?: "singleUse" | "multiUse" | "recurring";
         /**
-         * Participant emails for invitees with unknown status
+         * Status of the scheduling link
          */
-        unknownStatus: Array<string>;
+        status: string;
+        title?: string;
+        description?: string;
+        duration?: number;
         /**
-         * Readable participant events that overlap this meeting time, including the participant and whether each event creates a hard or soft conflict
+         * Full URL where invitees can book a meeting
          */
-        conflictingEvents: Array<{
-            participantEmail: string;
-            eventId: string;
-            summary?: string;
-            /**
-             * What kind of event is it? Standard, out of office, birthday...
-             */
-            eventType: "fromGmail" | "default" | "focusTime" | "outOfOffice" | "birthday" | "availability";
-            /**
-             * The calendar user's RSVP status
-             */
-            responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
-            conflictType: "hard" | "soft";
-        }>;
-    }>;
-    /**
-     * Whether one or more suggestions use a shorter duration than requested because no sufficiently conflict-free times were available at the requested duration
-     */
-    usedFlexibleDuration: boolean;
-    /**
-     * List of participant schedules, one for each individual participant, including resolved group members. Each schedule includes basic participant information and a list of the participant's calendar events.
-     */
-    participantSchedules?: Array<{
-        accountId: string;
-        coworkerEmail: string;
-        profile?: {
-            displayName?: string;
-            email?: string;
-            photoUrl?: string;
-        };
-        events: Array<{
-            eventId: string;
-            /**
-             * What kind of event is it? Standard, out of office, birthday...
-             */
-            eventType?: "fromGmail" | "default" | "focusTime" | "outOfOffice" | "birthday" | "availability";
-            /**
-             * Is an event confirmed, tentative or cancelled? This is different from the user's RSVP
-             */
-            eventStatus?: "confirmed" | "tentative" | "cancelled";
-            summary: string;
+        schedulingLinkUrl?: string;
+        timeRanges: Array<{
             /**
-             * When the event is happening
+             * Start of availability window in ISO 8601 format with timezone offset, e.g. '2024-08-22T09:00:00-04:00'
              */
-            period: {
-                type: "DATE";
-                start: {
-                    /**
-                     * Date in ISO 8601 format (no time)
-                     */
-                    date: string;
-                };
-                end: {
-                    /**
-                     * Date in ISO 8601 format (no time)
-                     */
-                    date: string;
-                };
-            } | {
-                type: "DATE_TIME";
-                start: {
-                    /**
-                     * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
-                     */
-                    dateTime: string;
-                    timeZone?: string;
-                };
-                end: {
-                    /**
-                     * Date-time in ISO 8601 format, in UTC (ending with Z), or with TZ offset
-                     */
-                    dateTime: string;
-                    timeZone?: string;
-                };
-            };
+            startDate: string;
             /**
-             * The calendar user's RSVP status
+             * End of availability window in ISO 8601 format with timezone offset, e.g. '2024-08-22T17:00:00-04:00'
              */
-            responseStatus?: "needsAction" | "accepted" | "declined" | "tentative";
-            colors?: {
-                foreground?: string;
-                background?: string;
-            };
+            endDate: string;
             /**
-             * If true, the event does not block time on the calendar. This is equivalent to setting `Show me as to Available` in the Calendar UI.
+             * Recurrence rules in RRULE format (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10']). Can also include EXDATE for exception dates (e.g., ['RRULE:FREQ=WEEKLY;COUNT=10', 'EXDATE:2026-03-24T13:00:00']).
              */
-            isTransparent: boolean;
+            recurrence?: Array<string>;
             /**
-             * Whether it's a meeting, aka an event with attendees listed
+             * Unique identifier for this time range
              */
-            isMeeting: boolean;
+            id: string;
         }>;
-    }>;
+    };
     errors?: Array<{
         /**
          * An identifier for the item that failed (e.g., event summary for creation, event ID for updates/cancellations)
@@ -1025,6 +2247,10 @@ export type SuggestMeetingTimesScriptOutput = {
 export declare class CalendarConnectionClient {
     private readonly invoke;
     constructor(invoke: ConnectionActionInvoker);
+    cancelEvents(args: CancelEventsScriptInput): Promise<CancelEventsScriptOutput>;
+    createEvents(args: CreateEventsScriptInput): Promise<CreateEventsScriptOutput>;
+    createSchedulingLink(args: CreateSchedulingLinkScriptInput): Promise<CreateSchedulingLinkScriptOutput>;
+    deleteSchedulingLinks(args: DeleteSchedulingLinksScriptInput): Promise<DeleteSchedulingLinksScriptOutput>;
     listCalendarResources(args: ListCalendarResourcesScriptInput): Promise<ListCalendarResourcesScriptOutput>;
     listCalendars(args: ListCalendarsScriptInput): Promise<ListCalendarsScriptOutput>;
     listContacts(args: ListContactsScriptInput): Promise<ListContactsScriptOutput>;
@@ -1032,5 +2258,7 @@ export declare class CalendarConnectionClient {
     listEvents(args: ListEventsScriptInput): Promise<ListEventsScriptOutput>;
     listSchedulingLinks(args: ListSchedulingLinksScriptInput): Promise<ListSchedulingLinksScriptOutput>;
     suggestMeetingTimes(args: SuggestMeetingTimesScriptInput): Promise<SuggestMeetingTimesScriptOutput>;
+    updateEvents(args: UpdateEventsScriptInput): Promise<UpdateEventsScriptOutput>;
+    updateSchedulingLink(args: UpdateSchedulingLinkScriptInput): Promise<UpdateSchedulingLinkScriptOutput>;
 }
 //# sourceMappingURL=calendar.generated.d.ts.map