Property Reference

This is the complete reference for all properties and methods available when writing gate functions. Consult this page while working in the Code Editor or reviewing code generated by the AI Generator.

GateEvent Properties

Every gate function receives a GateEvent object. It contains the event's core data plus computed convenience properties that simplify common checks.

Core Properties

These are the fundamental properties of every calendar event:

Property	Type	Description	Example Value
title	string	Event title/summary	"Team Standup"
description	string | null	Event description/notes	"Daily sync meeting"
location	string | null	Event location	"Conference Room A"
start	{ dateTime: string, timeZone: string | null }	Event start time (ISO 8601)	{ dateTime: "2026-02-14T14:00:00Z", timeZone: "America/New_York" }
end	{ dateTime: string, timeZone: string | null }	Event end time (ISO 8601)	{ dateTime: "2026-02-14T15:00:00Z", timeZone: "America/New_York" }
isAllDay	boolean	Whether the event is an all-day event	false
status	'confirmed' | 'tentative' | 'cancelled'	Event lifecycle status, set by the organizer for everyone (not your RSVP — see responseStatus)	"confirmed"
responseStatus	'accepted' | 'declined' | 'tentative' | 'needsAction' | 'organizer' | null	Your RSVP to the event (the connected calendar owner's response). null when you are not an attendee or the source calendar does not expose a response.	"needsAction"
showAs	'free' | 'busy' | null	Free/busy status	"busy"
attendees	Array<{ email: string, displayName?: string, status?: 'NEEDS-ACTION' | 'ACCEPTED' | 'DECLINED' | 'TENTATIVE' }>	List of event attendees. Each attendee's status is their own RSVP (iCalendar PARTSTAT), present when the source calendar exposes it.	[{ email: "alice@example.com", displayName: "Alice", status: "ACCEPTED" }]
organizer	{ email: string, displayName?: string } | null	Event organizer	{ email: "bob@example.com", displayName: "Bob" }
recurrence	string[] | null	Recurrence rules (iCalendar RRULE format)	["RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR"]
type	'default' | 'outOfOffice'	The kind of event	"default"

The type property reflects the event kind as reported by the source calendar provider:

Source	Value
Google out-of-office event	"outOfOffice"
Google focus time / working location / birthday / normal	"default"
Outlook event shown as "Out of office"	"outOfOffice"
Outlook anything else	"default"
Apple/CalDAV, ICS	"default"

Filtering by RSVP status

responseStatus reflects your own response to the event (the response on the connected source calendar), not the responses of other attendees. Use it to keep invitations you haven't accepted off your synced calendar:

function gate(event: GateEvent): GateResult {
  // Drop invitations you haven't accepted (declined or not yet responded)
  if (
    event.responseStatus === 'declined' ||
    event.responseStatus === 'needsAction'
  ) {
    return { pass: false, reason: 'Invitation not accepted' };
  }
  return { pass: true };
}

How each provider maps onto responseStatus:

responseStatus	Google	Microsoft	Apple / CalDAV (PARTSTAT)
accepted	accepted	accepted	ACCEPTED
declined	declined	declined	DECLINED
tentative	tentative	tentativelyAccepted	TENTATIVE
needsAction	needsAction	notResponded	NEEDS-ACTION
organizer	you organize it	organizer	you are the ORGANIZER
null	not an attendee	none / not invited	not listed as an attendee

note

A null value means there is no RSVP to evaluate — for example a personal event you created with no other invitees. Account for null explicitly if your rule should treat un-invited events differently from accepted ones.

status vs responseStatus vs attendees[].status

There are three RSVP-adjacent fields, and it's easy to confuse them:

	status	responseStatus	attendees[].status
Describes	The event's own lifecycle state	Your RSVP to the event	Each invitee's RSVP
Set by	The organizer — the same for everyone	You — yours alone	Each attendee individually
Answers	"Is this event happening?"	"Am I going?"	"Who else is going?"
Values	confirmed | tentative | cancelled	accepted | declined | tentative | needsAction | organizer | null	'NEEDS-ACTION' | 'ACCEPTED' | 'DECLINED' | 'TENTATIVE'

So a confirmed team meeting you were invited to but never answered is status: 'confirmed' and responseStatus: 'needsAction'.

Casing differs

responseStatus uses lowercase values ('accepted'), while attendees[].status uses the uppercase iCalendar PARTSTAT vocabulary ('ACCEPTED'). They describe the same idea from different vantage points — your own response vs. a specific attendee's — but responseStatus adds 'organizer'/null, and attendees[].status is omitted entirely when the source calendar doesn't expose it.

Watch out for 'tentative', which appears in both with different meanings:

• status === 'tentative' — the event itself is tentatively scheduled (the organizer hasn't firmed it up).
• responseStatus === 'tentative' — you replied "maybe".

The two compose naturally — use status to drop cancelled events and responseStatus to drop invitations you haven't accepted:

function gate(event: GateEvent): GateResult {
  if (event.status === 'cancelled') {
    return { pass: false, reason: 'Event cancelled' };
  }
  if (
    event.responseStatus === 'declined' ||
    event.responseStatus === 'needsAction'
  ) {
    return { pass: false, reason: 'Not accepted' };
  }
  return { pass: true };
}

Provider nuance

On Google the two are cleanly separated: status comes straight from the event and responseStatus from your own attendee entry. On Microsoft, status is derived (cancelled events, plus free/tentative showAs, are mapped to tentative), so responseStatus is the more reliable signal for "did I accept?".

Computed Convenience Properties

These are read-only properties computed from the core properties. They simplify common checks so you don't have to parse dates or count arrays yourself.

Property	Type	Description	Example Value
startDate	string	Alias for start.dateTime (ISO 8601)	"2026-02-14T14:00:00Z"
endDate	string	Alias for end.dateTime (ISO 8601)	"2026-02-14T15:00:00Z"
durationMinutes	number	Event duration in minutes	60
dayOfWeek	number	Day of week (0 = Sunday, 6 = Saturday), in UTC	1 (Monday)
hour	number	Hour of day the event starts (0-23), in UTC	14 (2 PM UTC)
isWeekday	boolean	Whether the event falls on Monday-Friday, in UTC	true
attendeeCount	number	Number of attendees	5

Computed properties are derived from core properties at sync time. For example, durationMinutes is calculated from start.dateTime and end.dateTime, and isWeekday is derived from dayOfWeek.

Times are evaluated in UTC

hour, dayOfWeek, and isWeekday are derived from the event's start time in UTC, not the event's (or your) local timezone. An event at 9 AM Pacific (UTC-7) has hour 16, and an event late on Sunday evening in a western timezone may already count as Monday. Shift your comparisons by your UTC offset — and remember the offset changes with daylight saving time. To work in the event's own timezone, parse start.dateTime together with start.timeZone yourself.

Helper Methods

GateEvent provides two helper methods for common pattern matching. Both perform case-insensitive matching.

Method	Signature	Returns	Description
hasAttendee(pattern)	(pattern: string) => boolean	boolean	Searches attendee email addresses for the given pattern
matches(pattern)	(pattern: string) => boolean	boolean	Searches the event title and description for the given pattern

hasAttendee(pattern)

Performs a case-insensitive search across all attendee email addresses. Returns true if any attendee's email contains the pattern.

// Check for a specific attendee
event.hasAttendee('alice@example.com'); // exact email match

// Check for a domain
event.hasAttendee('@company.com'); // any attendee from company.com

// Case-insensitive
event.hasAttendee('Alice@Example.COM'); // matches "alice@example.com"

matches(pattern)

Performs a case-insensitive search across both the event title and description. Returns true if either field contains the pattern.

// Match by keyword
event.matches('standup'); // matches "Daily Standup", "STANDUP MEETING", etc.

// Matches in title or description
event.matches('confidential'); // true if title OR description contains "confidential"

Prefer matches() over manual event.title/event.description checks — it handles null descriptions and case-insensitivity for you.

GateResult Interface

The gate function must return a GateResult object (or a simple boolean). Here is the full interface:

interface GateResult {
  pass: boolean;
  reason?: string;
  transform?: {
    title?: string;
    description?: string;
    location?: string;
    visibility?: 'default' | 'public' | 'private';
    showAs?: 'free' | 'busy';
    type?: 'default' | 'outOfOffice';
    autoDecline?: boolean;
    preBufferMinutes?: number;
    postBufferMinutes?: number;
  };
}

Fields

Field	Type	Required	Description
pass	boolean	Yes	true = sync the event to the target calendar. false = block (skip) the event.
reason	string	No	Human-readable explanation for the decision. Max 200 characters. Most useful when pass is false -- the reason appears in sync logs.
transform	object	No	Override event properties on the synced copy. Only applies when pass is true.

Transform Fields

Field	Type	Max Length	Description
title	string	500 chars	Replace the event title on the synced copy
description	string	5,000 chars	Replace the event description on the synced copy
location	string	500 chars	Replace the event location on the synced copy. Set to an empty string to clear it.
visibility	'default' | 'public' | 'private'	--	Change the event visibility
showAs	'free' | 'busy'	--	Change the free/busy status
preBufferMinutes	integer	0–60	Start the synced event earlier by N minutes (pre-event buffer). Ignored for all-day events.
postBufferMinutes	integer	0–60	End the synced event later by N minutes (post-event buffer). Ignored for all-day events.
type	'default' | 'outOfOffice'	--	Set the event kind in the destination calendar. See Out of office below.
autoDecline	boolean	--	Out of office only: auto-decline new conflicting invitations. See Out of office below.

Out of office

Set transform.type to "outOfOffice" to write the synced event as an Out of office event in the destination calendar.

• Google: writes a real Out of office event — requires the primary calendar of a Google Workspace account.
• Google personal accounts (@gmail.com), non-primary calendars, or all-day events: fall back to a busy event.
• Outlook: shown as "Out of office" on any calendar (no Workspace requirement).
• Apple/CalDAV, hosted calendars: falls back to a busy event.

Cannot be combined with showAs: "free" — out-of-office is always busy.

return { pass: true, transform: { type: 'outOfOffice' } };

Auto-decline new conflicting invitations (opt-in)

Set transform.autoDecline to true together with type: "outOfOffice" to have Google automatically decline new invitations that conflict with the synced Out of office event. Off by default.

• Forward-looking only: from the moment the Out of office block syncs, new conflicting invitations are declined. Events already on the calendar are never touched.
• Only effective where a real Out of office event is written — the primary calendar of a Google Workspace account. Everywhere else (Outlook, Apple/CalDAV, hosted, personal Google accounts, all-day events) the flag is ignored.
• Inviters see Google's standard decline message.

return { pass: true, transform: { type: 'outOfOffice', autoDecline: true } };

tip

Transforms only modify the synced copy on the target calendar. The original event on the source calendar is never changed.

Return Types

The gate function can return any of these types:

Boolean

The simplest return type. true passes the event, false blocks it:

function gate(event: GateEvent): boolean {
  return event.isWeekday;
}

GateResult

An object with pass, optional reason, and optional transform:

function gate(event: GateEvent): GateResult {
  return {
    pass: true,
    reason: 'Synced normally',
    transform: { title: `[Sync] ${event.title}` },
  };
}

GateResult | boolean

The union type allows mixing both styles in the same function:

function gate(event: GateEvent): GateResult | boolean {
  if (event.matches('confidential')) {
    return { pass: false, reason: 'Blocked confidential event' };
  }
  return true; // pass everything else
}

Complete Example

This comprehensive gate function demonstrates multiple properties, methods, and transform options:

function gate(event: GateEvent): GateResult {
  // Block confidential events entirely
  if (event.matches('confidential') || event.matches('secret')) {
    return { pass: false, reason: 'Blocked confidential event' };
  }

  // Block cancelled events
  if (event.status === 'cancelled') {
    return { pass: false, reason: 'Event is cancelled' };
  }

  // Redact personal events -- show the time block but hide details
  if (event.matches('personal') || event.matches('private')) {
    return {
      pass: true,
      transform: {
        title: 'Personal Event',
        description: '',
        visibility: 'private',
      },
    };
  }

  // Mark solo events (no other attendees) as free
  if (event.attendeeCount <= 1) {
    return {
      pass: true,
      transform: { showAs: 'free' },
    };
  }

  // Add prefix to large meetings (5+ attendees) for easy identification
  if (event.attendeeCount >= 5) {
    return {
      pass: true,
      transform: {
        title: `[Team] ${event.title}`,
      },
    };
  }

  // Pass everything else unchanged
  return { pass: true };
}

This example:

• Uses matches() for keyword filtering (confidential, personal)
• Checks status for cancelled events
• Uses attendeeCount for attendee-based logic
• Applies different transforms based on conditions
• Returns a reason for blocked events
• Falls through to a default pass for unmatched events

Related

• Code Editor — author and test functions with autocompletion.
• Cookbook — recipes that use these properties.
• Templates — common scenarios as one-click presets.