better-supabase 0.13.0 → 0.15.0

package/dist/blocks/calendar/index.d.ts

@@ -1,7 +1,181 @@
-import { tt as SchedulingEventData, wt as Events } from "../../events-DhGgwqQA.js";
-import { s as BlockOf } from "../../define-block-MyM4lH42.js";
-import { C as ToIcsOptions, S as ParsedIcs, T as toIcs, _ as AttendeeRole, a as fromEventCalendarUpdate, b as IcsEvent, c as toEventCalendarResources, d as OccurrenceOptions, f as OccurrenceRange, g as AttendeeResponse, h as splitRule, i as OccurrenceMove, l as CalendarEvent, m as expandOccurrences, n as EventCalendarOptions, o as seriesOf, p as SplitRules, r as EventCalendarResource, s as toEventCalendarEvents, t as EventCalendarEvent, u as CalendarOccurrence, v as CalendarAttendee, w as parseIcs, x as IcsSource, y as CalendarEventStatus } from "../../event-calendar-E6AI-dgg.js";
-import { a as createCalendarController, c as CalendarImport, d as SavedCalendarEvent, f as calendarEventOf, i as CalendarSnapshot, l as CalendarInfo, n as CalendarController, o as Calendar, p as createCalendar, r as CalendarControllerOptions, s as CalendarEventInput, t as CalendarActions, u as CalendarOptions } from "../../client-CXbP_p02.js";
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, b as DbError, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { t as StandardSchemaV1 } from "../../standard-DBV730sF.js";
+import { r as FieldsOf } from "../../block-fields-BE7pInWZ.js";
+import { Ct as Events, tt as SchedulingEventData } from "../../events-vcqenSYU.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "../../block-hooks-DZN2w69m.js";
+import { Sn as EntitySchema, c as BlockOf } from "../../define-block-BVcLQ3DF.js";
+import { n as Controller } from "../../controller-BrP0gn47.js";
+import { C as IcsEvent, D as parseIcs, E as ToIcsOptions, O as toIcs, S as CalendarEventStatus, T as ParsedIcs, _ as expandOccurrences, a as FreeBusy, b as AttendeeRole, c as WorkingHoursInput, d as workingHoursOf, f as CalendarEvent, g as SplitRules, h as OccurrenceRange, i as CommonFreeTimeOptions, l as commonFreeTime, m as OccurrenceOptions, n as CalendarEventKind, o as WeeklyHours, p as CalendarOccurrence, r as CalendarTransparency, s as WorkingHours, t as BusyRange, u as freeBusyOf, v as splitRule, w as IcsSource, x as CalendarAttendee, y as AttendeeResponse } from "../../availability-vguUvEK2.js";
+import { a as fromEventCalendarUpdate, c as toEventCalendarResources, i as OccurrenceMove, n as EventCalendarOptions, o as seriesOf, r as EventCalendarResource, s as toEventCalendarEvents, t as EventCalendarEvent } from "../../event-calendar-DCufbihU.js";
+import { t as VisibleRange } from "../../range-p5V4rBhZ.js";
+//#region src/blocks/calendar/calendar.d.ts
+interface CalendarOptions<S extends StandardSchemaV1 | undefined = undefined> {
+  /**
+   * A Standard Schema for the event columns the app adds
+   * (`blocks.calendar.options.extraColumns`), keyed by column name. It types
+   * and parses them on `events`, and validates them on `upsert` and the
+   * occurrence edits, which return a `validation` error for a bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Calendar<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+interface CalendarInfo {
+  readonly id: string;
+  readonly name: string;
+  readonly tz: string;
+  readonly color?: string;
+  readonly ownerType?: string;
+  readonly ownerId?: string;
+}
+/** The fields of an event to write. Fields left out keep their value on update. */
+interface CalendarEventInput {
+  readonly title?: string;
+  readonly description?: string | null;
+  readonly location?: string | null;
+  readonly startsAt?: Temporal.Instant;
+  readonly endsAt?: Temporal.Instant;
+  readonly allDay?: boolean;
+  readonly tz?: string;
+  readonly status?: CalendarEventStatus;
+  /** An RFC 5545 `RRULE` value, or `null` to end the recurrence. */
+  readonly rrule?: string | null;
+  readonly exdates?: readonly Temporal.Instant[];
+  readonly subjectType?: string | null;
+  readonly subjectId?: string | null;
+  readonly color?: string | null;
+  /** Default `event`. */
+  readonly kind?: CalendarEventKind;
+  /** Default `opaque`; `transparent` events don't make anyone busy. */
+  readonly transparency?: CalendarTransparency;
+  /**
+   * On an `out_of_office` or `focus_time` block: decline the owner's open
+   * invitations to single events it covers, and new ones. Default `false`.
+   */
+  readonly autoDecline?: boolean;
+  /** Only on insert. Default the new id. */
+  readonly uid?: string;
+}
+interface SavedCalendarEvent {
+  readonly id: string;
+  readonly uid: string;
+  readonly created: boolean;
+}
+interface CalendarImport {
+  readonly created: number;
+  readonly updated: number;
+  /** Events without a UID or DTSTART, and overrides of an unknown series. */
+  readonly skipped: number;
+}
+/** `F` is the extra event fields `options.fields` describes. */
+interface Calendar<F extends object = Record<never, never>> {
+  createCalendar(organizationId: string, name: string, options?: {
+    readonly tz?: string;
+    readonly ownerType?: string;
+    readonly ownerId?: string;
+  }): AsyncResult<{
+    readonly id: string;
+  }>;
+  deleteCalendar(id: string): AsyncResult<boolean>;
+  listCalendars(organizationId: string): AsyncResult<CalendarInfo[]>;
+  /**
+   * Inserts an event, or updates the one with `id`. Keys besides the input's
+   * own are the event's extra columns.
+   */
+  upsert(calendarId: string, input: CalendarEventInput & Partial<F> & {
+    readonly id?: string;
+  }): AsyncResult<SavedCalendarEvent>;
+  delete(eventId: string): AsyncResult<boolean>;
+  /** The rows that can fall in the range: events, series and their overrides. */
+  events(calendarIds: readonly string[], range: OccurrenceRange): AsyncResult<(CalendarEvent & F)[]>;
+  /** The occurrences in the range, series expanded. */
+  occurrences(calendarIds: readonly string[], range: OccurrenceRange, options?: OccurrenceOptions): AsyncResult<CalendarOccurrence[]>;
+  /** Changes one occurrence: an override for a series, else the event. */
+  editOccurrence(occurrence: CalendarOccurrence, changes: CalendarEventInput & Partial<F>): AsyncResult<SavedCalendarEvent>;
+  /**
+   * Changes an occurrence and every later one: splits the series, unless the
+   * occurrence is its first. Pass `rrule` when the change moves the weekday.
+   */
+  editFollowing(occurrence: CalendarOccurrence, changes: CalendarEventInput & Partial<F>): AsyncResult<{
+    readonly id: string;
+  }>;
+  /** Removes one occurrence of a series (an `EXDATE`), or a single event. */
+  cancelOccurrence(occurrence: CalendarOccurrence): AsyncResult<boolean>;
+  setAttendee(eventId: string, attendee: {
+    readonly email: string;
+    readonly name?: string;
+    readonly userId?: string;
+    readonly role?: AttendeeRole;
+  }): AsyncResult<boolean>;
+  removeAttendee(eventId: string, email: string): AsyncResult<boolean>;
+  /** The signed-in user answers an invitation. */
+  respond(eventId: string, response: AttendeeResponse): AsyncResult<boolean>;
+  /** Upserts the events of an iCalendar file by UID. */
+  importIcs(calendarId: string, text: string): AsyncResult<CalendarImport>;
+  /** The calendar's events as an iCalendar file. */
+  exportIcs(calendar: CalendarInfo, range?: OccurrenceRange): AsyncResult<string>;
+  /**
+   * The iCalendar feed of a share link to a calendar (`subjectType:
+   * "calendar"`), or `null` when the token is unknown, revoked or expired.
+   */
+  feed(token: string): AsyncResult<string | null>;
+  /** Replaces a member's weekly working hours. Returns how many stretches. */
+  setWorkingHours(organizationId: string, input: WorkingHoursInput): AsyncResult<number>;
+  /** The working hours of the members that set them (all when omitted). */
+  workingHours(organizationId: string, userIds?: readonly string[]): AsyncResult<WorkingHours[]>;
+  /**
+   * When each member is busy in the range (at most 62 days, 100 members):
+   * events on calendars they own, invitations they haven't declined,
+   * out-of-office and focus-time blocks, and approved leave. It returns ranges,
+   * never titles.
+   */
+  freeBusy(organizationId: string, userIds: readonly string[], range: OccurrenceRange): AsyncResult<FreeBusy[]>;
+}
+/** A `list_calendar_events` or `calendar_feed` row as an event. */
+export declare function calendarEventOf(value: unknown): CalendarEvent;
+export declare function createCalendar<S extends StandardSchemaV1 | undefined = undefined>(options: CalendarOptions<S>): Calendar<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/calendar/client.d.ts
+interface CalendarControllerOptions extends EventCalendarOptions {
+  readonly client: Pick<Calendar, "occurrences" | "editOccurrence" | "editFollowing" | "cancelOccurrence">;
+  readonly calendarIds: readonly string[];
+  /** The visible range; `setRange` changes it. */
+  readonly range: VisibleRange;
+}
+interface CalendarSnapshot {
+  /** `undefined` until the first load. */
+  readonly occurrences: readonly CalendarOccurrence[] | undefined;
+  /** The occurrences as event calendar events (ReUI's `CalendarEvent` shape). */
+  readonly events: readonly EventCalendarEvent<CalendarOccurrence>[];
+  readonly error: DbError | undefined;
+  /** True until the occurrences of the current range arrive. */
+  readonly loading: boolean;
+}
+interface CalendarActions {
+  readonly refresh: () => Promise<void>;
+  /** Saves one occurrence's change, then loads the range again. */
+  readonly editOccurrence: (occurrence: CalendarOccurrence, changes: CalendarEventInput) => Promise<boolean>;
+  /** Saves the change for this and every later occurrence, then loads again. */
+  readonly editFollowing: (occurrence: CalendarOccurrence, changes: CalendarEventInput) => Promise<boolean>;
+  readonly cancelOccurrence: (occurrence: CalendarOccurrence) => Promise<boolean>;
+  /** Shows another range; the current occurrences stay until its own arrive. */
+  readonly setRange: (range: VisibleRange) => void;
+}
+type CalendarController = Controller<CalendarSnapshot, CalendarActions>;
+/**
+ * The occurrences of some calendars in the visible range, typed for a headless
+ * event calendar such as ReUI's Event Calendar.
+ */
+export declare function createCalendarController(options: CalendarControllerOptions): CalendarController;
+//#endregion
 //#region src/blocks/calendar/events.d.ts
 /** The events of the `calendar` block: type to data. */
 type CalendarEvents = {
@@ -17,4 +191,11 @@ export declare const calendarEvents: Events<CalendarEvents>;
 /** The `calendar` block's manifest (ADR 0029). */
 export declare const calendarBlock: BlockOf<"calendar", typeof createCalendar, CalendarEvents>;
 //#endregion
-export { type AttendeeResponse, type AttendeeRole, type Calendar, type CalendarActions, type CalendarAttendee, type CalendarController, type CalendarControllerOptions, type CalendarEvent, type CalendarEventInput, type CalendarEventStatus, type CalendarEvents, type CalendarImport, type CalendarInfo, type CalendarOccurrence, type CalendarOptions, type CalendarSnapshot, type EventCalendarEvent, type EventCalendarOptions, type EventCalendarResource, type IcsEvent, type IcsSource, type OccurrenceMove, type OccurrenceOptions, type OccurrenceRange, type ParsedIcs, type SavedCalendarEvent, type SplitRules, type ToIcsOptions, calendarEventOf, createCalendar, createCalendarController, expandOccurrences, fromEventCalendarUpdate, parseIcs, seriesOf, splitRule, toEventCalendarEvents, toEventCalendarResources, toIcs };
+//#region src/blocks/calendar/schemas.d.ts
+/**
+ * What `upsert` takes for an event. Fields left out keep their value on update,
+ * so every field is optional.
+ */
+export declare const calendarEventInputSchema: EntitySchema<CalendarEventInput>;
+//#endregion
+export { type AttendeeResponse, type AttendeeRole, type BusyRange, type Calendar, type CalendarActions, type CalendarAttendee, type CalendarController, type CalendarControllerOptions, type CalendarEvent, type CalendarEventInput, type CalendarEventKind, type CalendarEventStatus, type CalendarEvents, type CalendarImport, type CalendarInfo, type CalendarOccurrence, type CalendarOptions, type CalendarSnapshot, type CalendarTransparency, type CommonFreeTimeOptions, type EventCalendarEvent, type EventCalendarOptions, type EventCalendarResource, type FreeBusy, type IcsEvent, type IcsSource, type OccurrenceMove, type OccurrenceOptions, type OccurrenceRange, type ParsedIcs, type SavedCalendarEvent, type SplitRules, type ToIcsOptions, type WeeklyHours, type WorkingHours, type WorkingHoursInput, commonFreeTime, expandOccurrences, freeBusyOf, fromEventCalendarUpdate, parseIcs, seriesOf, splitRule, toEventCalendarEvents, toEventCalendarResources, toIcs, workingHoursOf };