@kubun/connector-google-calendar 0.17.4 → 0.18.0

package/lib/actions.d.ts

@@ -1,4 +1,4 @@
-import type { ActionHandler } from '@kubun/connector';
+import { type ActionHandler } from '@kubun/connector';
 export type GoogleCalendarActionHandlerConfig = {
     credential: {
         accessToken: string;

package/lib/actions.js

@@ -1,3 +1,4 @@
+import { carryField, refuseCutLists } from '@kubun/connector';
 import { createEvent, updateEvent } from './api.js';
 import { GoogleCalendarError } from './errors.js';
 import { deriveEventID } from './event-id.js';
@@ -6,8 +7,9 @@ import { deriveEventID } from './event-id.js';
  * of the (possibly stale) local document. The one exception is how a changed
  * start/end is written: it keeps the event's all-day form and time zone from
  * the target document, and a changed time zone or all-day flag rewrites the
- * start and end it applies to.
- */ function sparsePatchParams(params, existing) {
+ * start and end it applies to. A value carried from the target document that
+ * was trimmed at sync is refused (`carryField`), never sent as the prefix.
+ */ function sparsePatchParams(params, existing, context) {
     const patch = {
         ...params
     };
@@ -21,13 +23,19 @@ import { deriveEventID } from './event-id.js';
         'endAt'
     ]){
         if (patch[field] == null && reshapesTimes && existing?.[field] != null) {
-            patch[field] = existing[field];
+            patch[field] = carryField(existing, field, context);
         }
     }
     const writesTimes = patch.startAt != null || patch.endAt != null;
     if (writesTimes) {
-        if (!('allDay' in patch) && existing?.allDay != null) patch.allDay = existing.allDay;
-        if (!('timeZone' in patch) && existing?.timeZone != null) patch.timeZone = existing.timeZone;
+        for (const field of [
+            'allDay',
+            'timeZone'
+        ]){
+            if (!(field in patch) && existing?.[field] != null) {
+                patch[field] = carryField(existing, field, context);
+            }
+        }
     }
     return patch;
 }
@@ -67,6 +75,7 @@ export function createGoogleCalendarActionHandler(config) {
             };
         },
         async update (_model, sourceID, params, existing, context) {
+            refuseCutLists(params, context);
             // sourceID is the composite calendarID/eventID. The target document
             // (`existing`) names the event; without it, recover both ids from the
             // composite — an eventID never contains '/', a calendarID may, so split
@@ -97,7 +106,7 @@ export function createGoogleCalendarActionHandler(config) {
                 accessToken: config.credential.accessToken,
                 calendarID,
                 eventID,
-                params: sparsePatchParams(params, existing),
+                params: sparsePatchParams(params, existing, context),
                 etag: context?.providerETag,
                 fetch: config.fetch
             });

package/lib/api.d.ts

@@ -23,6 +23,25 @@ export type GoogleEventDateTime = {
     date?: string;
     timeZone?: string;
 };
+export type GoogleResponseStatus = 'needsAction' | 'declined' | 'tentative' | 'accepted';
+export type GoogleEventAttendee = {
+    email?: string;
+    displayName?: string;
+    optional?: boolean;
+    resource?: boolean;
+    organizer?: boolean;
+    responseStatus?: GoogleResponseStatus;
+    self?: boolean;
+};
+export type GoogleEventOrganizer = {
+    email?: string;
+    displayName?: string;
+    self?: boolean;
+};
+export type GoogleEventReminder = {
+    method: 'popup' | 'email';
+    minutes: number;
+};
 export type GoogleEventResource = {
     id: string;
     etag?: string;
@@ -33,7 +52,22 @@ export type GoogleEventResource = {
     end: GoogleEventDateTime;
     status: 'confirmed' | 'tentative' | 'cancelled';
     htmlLink?: string;
-    recurringEventID?: string;
+    recurringEventId?: string;
+    originalStartTime?: GoogleEventDateTime;
+    recurrence?: Array<string>;
+    organizer?: GoogleEventOrganizer;
+    attendees?: Array<GoogleEventAttendee>;
+    reminders?: {
+        useDefault?: boolean;
+        overrides?: Array<GoogleEventReminder>;
+    };
+    hangoutLink?: string;
+    conferenceData?: {
+        entryPoints?: Array<{
+            entryPointType?: string;
+            uri?: string;
+        }>;
+    };
 };
 export type GoogleEventsListResponse = {
     items?: Array<GoogleEventResource>;
@@ -49,6 +83,8 @@ export type BuildEventsListURLParams = {
     syncToken?: string;
     pageToken?: string;
     timeMin?: string;
+    timeMax?: string;
+    showDeleted?: boolean;
 };
 export declare function buildEventsListURL(params: BuildEventsListURLParams): string;
 export declare function mapCalendarToEntity(calendar: GoogleCalendarResource, accountKey?: string): EntityRecord;
@@ -66,6 +102,12 @@ export declare function splitEventSourceID(sourceID: string): {
     calendarID: string;
     eventID: string;
 };
+export declare function fetchEventResource(config: {
+    accessToken: string;
+    calendarID: string;
+    eventID: string;
+    fetch?: typeof globalThis.fetch;
+}): Promise<GoogleEventResource>;
 export declare function getEvent(config: {
     accessToken: string;
     calendarID: string;

package/lib/api.js

@@ -1,6 +1,6 @@
 import { connectorHTTPError } from '@kubun/connector';
 import { createGoogleAPIClient } from '@kubun/provider-google';
-import { GoogleCalendarEventConflict } from './errors.js';
+import { GoogleCalendarError, GoogleCalendarEventConflict } from './errors.js';
 import { eventHoldsIntent } from './intent.js';
 export { classifyHTTPStatus } from '@kubun/connector';
 const CALENDAR_BASE_URL = 'https://www.googleapis.com/calendar/v3';
@@ -44,24 +44,46 @@ export function buildEventsListURL(params) {
     url.searchParams.set('singleEvents', 'true');
     if (params.syncToken != null) {
         url.searchParams.set('syncToken', params.syncToken);
-    } else if (params.timeMin != null) {
-        url.searchParams.set('timeMin', params.timeMin);
+    } else {
+        if (params.timeMin != null) {
+            url.searchParams.set('timeMin', params.timeMin);
+        }
+        if (params.timeMax != null) {
+            url.searchParams.set('timeMax', params.timeMax);
+        }
+        if (params.showDeleted === true) {
+            url.searchParams.set('showDeleted', 'true');
+        }
     }
     if (params.pageToken != null) {
         url.searchParams.set('pageToken', params.pageToken);
     }
     return url.toString();
 }
+const CALENDAR_ACCESS_ROLES = {
+    owner: 'OWNER',
+    writer: 'WRITER',
+    reader: 'READER',
+    freeBusyReader: 'FREE_BUSY'
+};
+const HEX_COLOR = /^#[0-9A-Fa-f]{6}$/;
+// An empty provider string is no value: the model's text fields hold at least
+// one character.
+function text(value) {
+    return value == null || value === '' ? undefined : value;
+}
 export function mapCalendarToEntity(calendar, accountKey) {
+    const color = calendar.backgroundColor;
     return {
         sourceService: 'google-calendar',
         sourceID: calendar.id,
         sourceURL: 'https://calendar.google.com',
-        summary: calendar.summary,
-        description: calendar.description,
+        name: text(calendar.summary) ?? '(No title)',
+        description: text(calendar.description),
         timeZone: calendar.timeZone,
         primary: calendar.primary ?? false,
-        backgroundColor: calendar.backgroundColor,
+        color: color != null && HEX_COLOR.test(color) ? color : undefined,
+        accessRole: calendar.accessRole == null ? undefined : CALENDAR_ACCESS_ROLES[calendar.accessRole],
         ...accountKey != null ? {
             accountKey
         } : {}
@@ -73,10 +95,73 @@ export function mapCalendarToEntity(calendar, accountKey) {
 function allDayDateToDateTime(date) {
     return date == null ? undefined : `${date}T00:00:00.000Z`;
 }
+function toDateTime(value) {
+    if (value == null) return undefined;
+    return value.date != null ? allDayDateToDateTime(value.date) : value.dateTime;
+}
+const RESPONSE_STATUS_TO_PARTY = {
+    needsAction: 'NEEDS_ACTION',
+    accepted: 'ACCEPTED',
+    declined: 'DECLINED',
+    tentative: 'TENTATIVE'
+};
+const PARTY_STATUS_TO_RESPONSE = {
+    NEEDS_ACTION: 'needsAction',
+    ACCEPTED: 'accepted',
+    DECLINED: 'declined',
+    TENTATIVE: 'tentative'
+};
+const REMINDER_TO_METHOD = {
+    popup: 'DISPLAY',
+    email: 'EMAIL'
+};
+const METHOD_TO_REMINDER = {
+    DISPLAY: 'popup',
+    EMAIL: 'email'
+};
+function mapAttendee(attendee) {
+    const party = {};
+    if (attendee.email != null) party.email = attendee.email;
+    const name = text(attendee.displayName);
+    if (name != null) party.name = name;
+    party.role = attendee.organizer === true ? 'CHAIR' : attendee.resource === true ? 'RESOURCE' : attendee.optional === true ? 'OPTIONAL' : 'REQUIRED';
+    const status = attendee.responseStatus == null ? undefined : RESPONSE_STATUS_TO_PARTY[attendee.responseStatus];
+    if (status != null) party.status = status;
+    if (attendee.self != null) party.self = attendee.self;
+    return party;
+}
+function mapOrganizer(organizer) {
+    if (organizer == null) return undefined;
+    const party = {};
+    if (organizer.email != null) party.email = organizer.email;
+    const name = text(organizer.displayName);
+    if (name != null) party.name = name;
+    party.role = 'CHAIR';
+    if (organizer.self != null) party.self = organizer.self;
+    return party;
+}
+// Calendar defaults (`useDefault`) are the calendar's, not the event's, so
+// they leave the event's reminders unset. An event that turns them off with no
+// overrides has no reminders: an empty list, distinct from the defaults.
+function mapReminders(event) {
+    const reminders = event.reminders;
+    if (reminders == null || reminders.useDefault === true) return undefined;
+    return (reminders.overrides ?? []).map((reminder)=>({
+            method: REMINDER_TO_METHOD[reminder.method],
+            minutesBefore: reminder.minutes
+        }));
+}
+// The Meet link Google keeps on the event, or else the first video entry
+// point of any other conference (Zoom, Teams...).
+function mapConferenceURL(event) {
+    if (event.hangoutLink != null) return event.hangoutLink;
+    return event.conferenceData?.entryPoints?.find((entry)=>entry.entryPointType === 'video')?.uri;
+}
+function nonEmpty(items) {
+    return items == null || items.length === 0 ? undefined : items;
+}
 export function mapEventToEntity(event, calendarID) {
     const allDay = event.start.date != null;
-    const startAt = allDay ? allDayDateToDateTime(event.start.date) : event.start.dateTime;
-    const endAt = allDay ? allDayDateToDateTime(event.end.date) : event.end.dateTime;
     return {
         sourceService: 'google-calendar',
         // Google event ids are unique per calendar, not per account; namespace the
@@ -85,16 +170,22 @@ export function mapEventToEntity(event, calendarID) {
         sourceID: `${calendarID}/${event.id}`,
         eventID: event.id,
         sourceURL: event.htmlLink,
-        title: event.summary ?? '(No title)',
-        description: event.description,
-        location: event.location,
+        title: text(event.summary) ?? '(No title)',
+        description: text(event.description),
+        location: text(event.location),
         allDay,
-        startAt,
-        endAt,
+        startAt: toDateTime(event.start),
+        endAt: toDateTime(event.end),
         status: event.status.toUpperCase(),
         htmlLink: event.htmlLink,
-        recurringEventID: event.recurringEventID,
         timeZone: event.start.timeZone,
+        organizer: mapOrganizer(event.organizer),
+        participants: nonEmpty(event.attendees)?.map(mapAttendee),
+        recurrence: nonEmpty(event.recurrence),
+        seriesID: event.recurringEventId,
+        originalStartAt: toDateTime(event.originalStartTime),
+        reminders: mapReminders(event),
+        conferenceURL: mapConferenceURL(event),
         calendarID,
         calendar: {
             sourceService: 'google-calendar',
@@ -103,6 +194,52 @@ export function mapEventToEntity(event, calendarID) {
         etag: event.etag
     };
 }
+function participantToAttendee(participant) {
+    const party = participant ?? {};
+    if (typeof party.email !== 'string' || party.email === '') {
+        throw new GoogleCalendarError('a Google Calendar participant needs an email', {
+            kind: 'rejected'
+        });
+    }
+    // A chair is the event's organizer attending it. Google's attendee
+    // `organizer` flag is read-only and the organizer is fixed by the event
+    // itself, so a chair is sent as a plain required attendee: keeping the entry
+    // keeps the organizer's attendance. Google has no attendee role for a
+    // non-participant, so that one is refused, never sent as a plain attendee.
+    if (party.role === 'NON_PARTICIPANT') {
+        throw new GoogleCalendarError(`a Google Calendar participant cannot have the ${party.role} role`, {
+            kind: 'rejected'
+        });
+    }
+    const attendee = {
+        email: party.email
+    };
+    if (typeof party.name === 'string') attendee.displayName = party.name;
+    if (party.role === 'OPTIONAL') attendee.optional = true;
+    if (party.role === 'RESOURCE') attendee.resource = true;
+    const responseStatus = typeof party.status === 'string' ? PARTY_STATUS_TO_RESPONSE[party.status] : undefined;
+    if (responseStatus != null) attendee.responseStatus = responseStatus;
+    return attendee;
+}
+function remindersToGoogle(reminders) {
+    return {
+        // An explicit list, even an empty one, replaces the calendar defaults.
+        useDefault: false,
+        overrides: reminders.map((value)=>{
+            const reminder = value ?? {};
+            const method = METHOD_TO_REMINDER[reminder.method];
+            if (method == null || typeof reminder.minutesBefore !== 'number') {
+                throw new GoogleCalendarError('a Google Calendar reminder needs a DISPLAY or EMAIL method and minutesBefore', {
+                    kind: 'rejected'
+                });
+            }
+            return {
+                method,
+                minutes: reminder.minutesBefore
+            };
+        })
+    };
+}
 export function buildEventFromParams(params, options) {
     const event = {};
     const allDay = params.allDay === true;
@@ -145,6 +282,17 @@ export function buildEventFromParams(params, options) {
             } : {}
         };
     }
+    // Each list replaces the event's whole list at Google: a sparse PATCH that
+    // carries one sends it complete.
+    if (Array.isArray(params.participants)) {
+        event.attendees = params.participants.map(participantToAttendee);
+    }
+    if (Array.isArray(params.recurrence)) {
+        event.recurrence = params.recurrence;
+    }
+    if (Array.isArray(params.reminders)) {
+        event.reminders = remindersToGoogle(params.reminders);
+    }
     return event;
 }
 // One calendar as the account's calendar list holds it (calendarList.get) —
@@ -167,7 +315,7 @@ export function splitEventSourceID(sourceID) {
         eventID: sourceID.slice(slash + 1)
     };
 }
-async function fetchEventResource(config) {
+export async function fetchEventResource(config) {
     const url = `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(config.calendarID)}/events/${encodeURIComponent(config.eventID)}`;
     return calendarAPIClient(config.accessToken, config.fetch).get(url);
 }
@@ -231,7 +379,9 @@ export async function createEvent(config) {
 }
 export async function updateEvent(config) {
     const event = buildEventFromParams(config.params);
-    const url = `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(config.calendarID)}/events/${encodeURIComponent(config.eventID)}`;
+    // Guest notification is not part of a write-back: an edit synced from a
+    // device never emails the event's guests.
+    const url = `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(config.calendarID)}/events/${encodeURIComponent(config.eventID)}?sendUpdates=none`;
     const data = await calendarAPIClient(config.accessToken, config.fetch).send(url, {
         method: 'PATCH',
         body: event,

package/lib/connector.js

@@ -1,9 +1,23 @@
+import { calendarModelDefinitions } from '@kubun/models-calendar';
 import { createGoogleCalendarActionHandler } from './actions.js';
 import { canonicalizeEventIntent } from './intent.js';
 import { googleCalendarClusters } from './model.js';
 import { predictCreatedEventSourceID } from './predict.js';
 import { createGoogleCalendarProvider } from './provider.js';
 import { resolveCalendarTarget } from './target.js';
+const eventKindProperties = calendarModelDefinitions.find((definition)=>definition.name === 'EventKind')?.schema?.properties ?? {};
+function eventKindProperty(name) {
+    const property = eventKindProperties[name];
+    if (property == null) throw new Error(`EventKind declares no "${name}" field`);
+    return property;
+}
+// The event lists a write can set, in the EventKind shape. Each one replaces
+// the event's whole list at Google.
+const eventListInputProperties = {
+    participants: eventKindProperty('participants'),
+    recurrence: eventKindProperty('recurrence'),
+    reminders: eventKindProperty('reminders')
+};
 export function createGoogleCalendarConnector(options) {
     return {
         name: 'google-calendar',
@@ -15,6 +29,8 @@ export function createGoogleCalendarConnector(options) {
         actions: [
             {
                 name: 'create',
+                // Events only: no mutation is generated for GoogleCalendar.
+                entityModel: 'GoogleCalendarEvent',
                 description: 'Create a Google Calendar event',
                 input: {
                     type: 'object',
@@ -42,7 +58,8 @@ export function createGoogleCalendarConnector(options) {
                         },
                         timeZone: {
                             type: 'string'
-                        }
+                        },
+                        ...eventListInputProperties
                     }
                 },
                 requiresCredential: true,
@@ -54,6 +71,8 @@ export function createGoogleCalendarConnector(options) {
             },
             {
                 name: 'update',
+                // Events only: no mutation is generated for GoogleCalendar.
+                entityModel: 'GoogleCalendarEvent',
                 description: 'Update a Google Calendar event',
                 input: {
                     type: 'object',
@@ -81,7 +100,8 @@ export function createGoogleCalendarConnector(options) {
                         },
                         timeZone: {
                             type: 'string'
-                        }
+                        },
+                        ...eventListInputProperties
                     }
                 },
                 requiresCredential: true,

package/lib/intent.d.ts

@@ -7,6 +7,10 @@ import type { EntityRecord, IntentCanonicalizer } from '@kubun/connector';
  *   value never matches a timed one;
  * - `calendarID` is compared exactly: an operation's intent already carries
  *   the calendar the `'primary'` alias was resolved to before the claim;
+ * - participants are compared by email and role only, in any order: Google
+ *   sets each attendee's response status and display name itself;
+ * - reminders are compared exactly: an empty list (the event's reminders
+ *   turned off) is not the calendar defaults (unset);
  * - a cancelled (deleted) event holds no create or update.
  */
 export declare const canonicalizeEventIntent: IntentCanonicalizer;

package/lib/intent.js

@@ -25,6 +25,10 @@ function canonicalDateTime(value, allDay) {
  *   value never matches a timed one;
  * - `calendarID` is compared exactly: an operation's intent already carries
  *   the calendar the `'primary'` alias was resolved to before the claim;
+ * - participants are compared by email and role only, in any order: Google
+ *   sets each attendee's response status and display name itself;
+ * - reminders are compared exactly: an empty list (the event's reminders
+ *   turned off) is not the calendar defaults (unset);
  * - a cancelled (deleted) event holds no create or update.
  */ export const canonicalizeEventIntent = ({ model, intent, record })=>{
     if (model !== googleCalendarEventDefinition.name) return {
@@ -54,11 +58,30 @@ function canonicalDateTime(value, allDay) {
         }
         canonicalRecord[field] = canonicalDateTime(canonicalRecord[field], recordAllDay);
     }
+    if ('participants' in canonicalIntent) {
+        canonicalIntent.participants = canonicalParticipants(canonicalIntent.participants);
+        canonicalRecord.participants = canonicalParticipants(canonicalRecord.participants);
+    }
     return {
         intent: canonicalIntent,
         record: canonicalRecord
     };
 };
+// A participant list as Google keeps it: each attendee's email (compared
+// case-insensitively) and role, in no particular order. Google sets the
+// response status, the reader's own entry and display names itself, so they
+// are not part of what a write intends.
+function canonicalParticipants(value) {
+    if (value == null) return [];
+    if (!Array.isArray(value)) return value;
+    return value.map((item)=>{
+        const party = item ?? {};
+        return {
+            email: typeof party.email === 'string' ? party.email.toLowerCase() : party.email,
+            role: party.role ?? 'REQUIRED'
+        };
+    }).sort((a, b)=>String(a.email).localeCompare(String(b.email)));
+}
 function canonicalOf(value) {
     return toB64U(digestJSON(value === undefined ? null : value));
 }

package/lib/model.d.ts

@@ -1,25 +1,13 @@
 export declare const googleCalendarDefinition: {
     readonly name: "GoogleCalendar";
     readonly behavior: "default";
-    readonly interfaces: [string];
+    readonly interfaces: [string, string];
     readonly schema: {
         readonly type: "object";
         readonly properties: {
-            readonly summary: {
-                readonly type: "string";
-            };
-            readonly description: {
-                readonly type: "string";
-            };
-            readonly timeZone: {
-                readonly $ref: "#/definitions/TimeZone";
-            };
             readonly primary: {
                 readonly type: "boolean";
             };
-            readonly backgroundColor: {
-                readonly type: "string";
-            };
             readonly accountKey: {
                 readonly type: "string";
                 readonly minLength: 43;
@@ -38,10 +26,9 @@ export declare const googleCalendarDefinition: {
                 readonly $ref: "#/definitions/DateTime";
             };
         };
-        readonly required: ["summary", "sourceService", "sourceID", "lastSyncedAt"];
+        readonly required: ["sourceService", "sourceID", "lastSyncedAt"];
         readonly additionalProperties: false;
         readonly definitions: {
-            readonly TimeZone: import("json-schema-typed").JSONSchema.String;
             readonly SourceService: {
                 readonly type: "string";
                 readonly title: "SourceService";
@@ -63,46 +50,20 @@ export declare const googleCalendarDefinition: {
         };
     };
     readonly fieldsMeta: {};
+    readonly providerMergePolicy: {
+        readonly group: [...string[], "primary", "sourceService", "sourceID", "sourceURL"];
+    };
 };
 export declare const googleCalendarEventDefinition: {
     readonly name: "GoogleCalendarEvent";
     readonly behavior: "default";
-    readonly interfaces: [string, string];
+    readonly interfaces: [string, string, string];
     readonly schema: {
         readonly type: "object";
         readonly properties: {
-            readonly title: {
-                readonly type: "string";
-                readonly minLength: 1;
-                readonly maxLength: 200;
-            };
-            readonly startAt: {
-                readonly $ref: "#/definitions/DateTime";
-            };
-            readonly endAt: {
-                readonly $ref: "#/definitions/DateTime";
-            };
-            readonly allDay: {
-                readonly type: "boolean";
-            };
-            readonly timeZone: {
-                readonly $ref: "#/definitions/TimeZone";
-            };
-            readonly description: {
-                readonly type: "string";
-            };
-            readonly location: {
-                readonly type: "string";
-            };
-            readonly status: {
-                readonly $ref: "#/definitions/EventStatus";
-            };
             readonly htmlLink: {
                 readonly $ref: "#/definitions/HtmlLink";
             };
-            readonly recurringEventID: {
-                readonly type: "string";
-            };
             readonly eventID: {
                 readonly type: "string";
             };
@@ -128,7 +89,7 @@ export declare const googleCalendarEventDefinition: {
                 readonly $ref: "#/definitions/DateTime";
             };
         };
-        readonly required: ["title", "startAt", "allDay", "calendarID", "calendar", "sourceService", "sourceID", "lastSyncedAt"];
+        readonly required: ["calendarID", "calendar", "sourceService", "sourceID", "lastSyncedAt"];
         readonly additionalProperties: false;
         readonly definitions: {
             readonly SourceID: {
@@ -137,7 +98,6 @@ export declare const googleCalendarEventDefinition: {
                 readonly minLength: 1;
                 readonly maxLength: 1400;
             };
-            readonly TimeZone: import("json-schema-typed").JSONSchema.String;
             readonly HtmlLink: {
                 readonly type: "string";
                 readonly format: "uri";
@@ -148,11 +108,6 @@ export declare const googleCalendarEventDefinition: {
                 readonly title: "DocID";
                 readonly pattern: "^k[0-9a-z]{10,120}$";
             };
-            readonly EventStatus: {
-                readonly type: "string";
-                readonly title: "EventStatus";
-                readonly enum: ["CONFIRMED", "TENTATIVE", "CANCELLED"];
-            };
             readonly SourceService: {
                 readonly type: "string";
                 readonly title: "SourceService";
@@ -174,7 +129,7 @@ export declare const googleCalendarEventDefinition: {
         };
     };
     readonly providerMergePolicy: {
-        readonly group: ["title", "startAt", "endAt", "allDay", "timeZone", "description", "location", "status", "htmlLink", "recurringEventID", "eventID", "calendarID", "calendar", "sourceService", "sourceID", "sourceURL", "etag"];
+        readonly group: ["title", ...string[], "htmlLink", "eventID", "calendarID", "calendar", "sourceService", "sourceID", "sourceURL", "etag"];
     };
 };
 export declare const googleCalendarClusters: import("@kubun/protocol").ClustersRecord;