@onecal/unified-calendar-api-node-sdk 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,786 @@
+import { AxiosRequestConfig } from 'axios';
+export { getOAuthUrl } from './oauth/index.js';
+
+/**
+ * Core types for the Unified Calendar API SDK
+ */
+interface UnifiedCalendarApiConfig {
+    /**
+     * Your Unified Calendar API key (required)
+     */
+    apiKey: string;
+    /**
+     * Base URL for the API (default: https://api.onecalunified.com)
+     */
+    unifiedApiBaseUrl?: string;
+    /**
+     * Request timeout in milliseconds (default: 30000)
+     */
+    timeout?: number;
+}
+interface PaginationParams {
+    /**
+     * Page token for pagination
+     */
+    pageToken?: string;
+    /**
+     * Number of results per page
+     */
+    pageSize?: number;
+    /**
+     * Sync token for incremental sync
+     */
+    syncToken?: string;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    pageToken?: string;
+    nextPageToken?: string;
+    syncToken?: string;
+}
+interface APIResponse<T> {
+    data: T;
+    success?: boolean;
+    message?: string;
+}
+interface APIError {
+    code?: string;
+    message: string;
+    details?: Record<string, any>;
+    status?: number;
+}
+
+/**
+ * Calendar types
+ */
+
+interface Calendar {
+    /** Unique identifier for the calendar */
+    id: string;
+    /** Display name of the calendar */
+    name: string;
+    /** Hexadecimal color code representing the calendar's color */
+    hexColor?: string;
+    /** Indicates whether the calendar is a read-only calendar */
+    readOnly?: boolean;
+    /** Indicates whether this calendar is the primary calendar within this End User Account */
+    isPrimary?: boolean;
+    /** Indicates whether the calendar is a shared calendar to this End User Account */
+    isShared?: boolean;
+    /** Time zone associated with the calendar */
+    timeZone?: string;
+    /** Email address used for calendar invitations to and from this calendar */
+    inviteEmail?: string;
+    /** List of allowed online meeting providers for this calendar */
+    allowedOnlineMeetingProviders?: string[];
+    /** Default online meeting provider used for this calendar */
+    defaultOnlineMeetingProvider?: string;
+}
+interface CreateCalendarInput {
+    /** Display name for the new calendar */
+    name: string;
+    /** Hexadecimal color code for the calendar */
+    hexColor?: string;
+    /** Time zone associated with the calendar */
+    timeZone?: string;
+}
+interface UpdateCalendarInput {
+    /** Updated display name for the calendar */
+    name?: string;
+    /** Updated hexadecimal color code for the calendar */
+    hexColor?: string;
+    /** Updated time zone associated with the calendar */
+    timeZone?: string;
+}
+interface ListCalendarsParams extends PaginationParams {
+}
+
+/**
+ * Event types
+ */
+
+declare enum EventColorId {
+    LAVENDER = "1",
+    SAGE = "2",
+    GRAPE = "3",
+    FLAMINGO = "4",
+    BANANA = "5",
+    TANGERINE = "6",
+    PEACOCK = "7",
+    GRAPHITE = "8",
+    BLUEBERRY = "9",
+    BASIL = "10",
+    TOMATO = "11"
+}
+declare enum EventOrderBy {
+    START_TIME = "startDateTime",
+    UPDATED = "updatedDateTime"
+}
+interface EventDateTime {
+    /** Date and time in ISO 8601 format (e.g., 2023-03-15T10:00:00) */
+    dateTime?: string;
+    /** Time zone identifier (e.g., America/New_York) */
+    timeZone?: string;
+}
+interface EventAttendee {
+    /** Unique identifier of the attendee */
+    id?: string;
+    /** Full name of the attendee */
+    name?: string;
+    /** Email address of the attendee */
+    email: string;
+    /** The attendee's response to the invitation */
+    responseStatus?: 'needsAction' | 'declined' | 'tentative' | 'accepted';
+}
+interface EventActor {
+    /** Unique identifier for the actor (optional) */
+    id?: string;
+    /** Display name of the actor (optional) */
+    name?: string;
+    /** Email address of the actor (optional) */
+    email?: string;
+    /** Whether this actor is the current user */
+    isSelf?: boolean;
+}
+interface ConferenceData {
+    /** Conference identifier from the provider (optional) */
+    conferenceId?: string;
+    /** URL to join the conference */
+    joinUrl?: string;
+    /** Type of conference (e.g., hangoutsMeet, zoom, teams) */
+    conferenceType?: string;
+    /** Additional conference details specific to the provider */
+    conferenceDetails?: Record<string, any>;
+}
+interface EventReminder {
+    /** Reminder notification method (e.g., email, popup) */
+    method?: string;
+    /** Number of minutes before the event to trigger the reminder */
+    minutes?: number;
+}
+interface EventReminders {
+    /** Whether to use the calendar's default reminder settings */
+    useDefault?: boolean;
+    /** Whether reminders are enabled for this event */
+    isReminderOn?: boolean;
+    /** Custom reminder overrides */
+    overrides?: EventReminder[];
+}
+interface Event {
+    /** Unique identifier for the event */
+    id: string;
+    /** Title or summary of the event */
+    title: string;
+    /** Detailed description or notes about the event */
+    description?: string;
+    /** ETag of the event for version control */
+    etag?: string;
+    /** Event start date and time */
+    start: EventDateTime;
+    /** Event end date and time */
+    end: EventDateTime;
+    /** Indicates whether the event lasts all day */
+    isAllDay?: boolean;
+    /** Physical or virtual location of the event */
+    location?: string;
+    /** ID representing the event color */
+    colorId?: EventColorId;
+    /** Custom color code applied to this event */
+    customColor?: string;
+    /** The user's response to the event invitation */
+    myResponseStatus?: 'needsAction' | 'declined' | 'tentative' | 'accepted';
+    /** List of attendees invited to the event */
+    attendees?: EventAttendee[];
+    /** Information about the organizer of the event */
+    organizer?: EventActor;
+    /** Information about the creator of the event */
+    creator?: EventActor;
+    /** Visibility level of the event */
+    visibility?: 'default' | 'public' | 'private' | 'confidential';
+    /** Indicates whether the event blocks time on the calendar */
+    transparency?: 'transparent' | 'opaque';
+    /** Type of the event */
+    eventType?: 'default' | 'outOfOffice' | 'focusTime';
+    /** Recurrence rules describing how often the event repeats */
+    recurrence?: string[];
+    /** ID of the recurring event this instance belongs to */
+    recurringEventId?: string;
+    /** Indicates whether the event is part of a recurring series */
+    isRecurring?: boolean;
+    /** Indicates whether the event is an exception in a recurring series */
+    isException?: boolean;
+    /** Indicates whether the event has been canceled */
+    isCancelled?: boolean;
+    /** Original start date and time of the event before modification */
+    originalStart?: EventDateTime;
+    /** Information about an associated conference meeting, if any */
+    conferenceData?: ConferenceData;
+    /** URL link to view the event in a calendar interface */
+    webLink?: string;
+    /** iCalendar UID for cross-system identification */
+    iCalUid?: string;
+    /** Event reminder settings */
+    reminders?: EventReminders;
+    /** Custom key-value properties visible to others */
+    publicExtendedProperties?: Record<string, string>;
+    /** Custom key-value properties visible only to the authenticated user */
+    privateExtendedProperties?: Record<string, string>;
+    /** ISO 8601 date-time when the event was created */
+    createdAt?: string;
+    /** ISO 8601 date-time when the event was last updated */
+    updatedAt?: string;
+}
+interface CreateEventInput {
+    /** Optional custom ID for the event (if not provided, one will be generated) */
+    id?: string;
+    /** Title or summary of the event */
+    title: string;
+    /** Detailed description or notes about the event */
+    description?: string;
+    /** Event start date and time */
+    start: EventDateTime;
+    /** Event end date and time */
+    end: EventDateTime;
+    /** Indicates whether the event lasts all day */
+    isAllDay?: boolean;
+    /** Physical or virtual location of the event */
+    location?: string;
+    /** ID representing the event color */
+    colorId?: EventColorId;
+    /** Custom color code applied to this event */
+    customColor?: string;
+    /** The user's response to the event invitation */
+    myResponseStatus?: 'needsAction' | 'declined' | 'tentative' | 'accepted';
+    /** List of attendees invited to the event */
+    attendees?: EventAttendee[];
+    /** Visibility level of the event */
+    visibility?: 'default' | 'public' | 'private' | 'confidential';
+    /** Indicates whether the event blocks time on the calendar */
+    transparency?: 'transparent' | 'opaque';
+    /** Type of the event */
+    eventType?: 'default' | 'outOfOffice' | 'focusTime';
+    /** Recurrence rules describing how often the event repeats */
+    recurrence?: string[];
+    /** ID of the recurring event this instance belongs to */
+    recurringEventId?: string;
+    /** Indicates whether the event is part of a recurring series */
+    isRecurring?: boolean;
+    /** Indicates whether the event is an exception in a recurring series */
+    isException?: boolean;
+    /** Indicates whether the event has been canceled */
+    isCancelled?: boolean;
+    /** Original start date and time of the event before modification */
+    originalStart?: EventDateTime;
+    /** Information about an associated conference meeting, if any */
+    conferenceData?: ConferenceData;
+    /** URL link to view the event in a calendar interface */
+    webLink?: string;
+    /** Event reminder settings */
+    reminders?: EventReminders;
+    /** Custom key-value properties visible to others */
+    publicExtendedProperties?: Record<string, string>;
+    /** Custom key-value properties visible only to the authenticated user */
+    privateExtendedProperties?: Record<string, string>;
+    /** Information about the organizer of the event */
+    organizer?: EventActor;
+    /** Information about the creator of the event */
+    creator?: EventActor;
+    /** Provider used to automatically generate a meeting URL */
+    generateMeetingUrlProvider?: string;
+}
+interface UpdateEventInput extends Partial<Omit<CreateEventInput, 'id' | 'generateMeetingUrlProvider'>> {
+}
+interface ListEventsParams extends PaginationParams {
+    /** ISO 8601 date-time to filter events that start after this time */
+    startDateTime?: Date | string;
+    /** ISO 8601 date-time to filter events that end before this time */
+    endDateTime?: Date | string;
+    /** Display all events in the specified time zone */
+    timeZone?: string;
+    /** JSON object to filter events by custom properties */
+    metadataFilters?: Record<string, any>;
+    /** Whether to expand the recurrence of recurring events into individual events. If provided, startDateTime and endDateTime are required. By default recurring events are not expanded */
+    expandRecurrences?: boolean;
+    /** Search for events by title */
+    search?: string;
+    /** Filter for all-day events only */
+    isAllDay?: boolean;
+    /** Include or exclude cancelled events */
+    isCancelled?: boolean;
+    /** Only return events updated after this date/time (ISO 8601 format or Date object) */
+    updatedAfter?: Date | string;
+    /** Field to order events by. Only available when expandRecurrences is true */
+    orderBy?: EventOrderBy;
+}
+interface RSVPInput {
+    /** The user's response to the event invitation */
+    responseStatus: 'needsAction' | 'declined' | 'tentative' | 'accepted';
+}
+
+/**
+ * End User Account types
+ */
+declare enum ProviderType {
+    GOOGLE = "GOOGLE",
+    MICROSOFT = "MICROSOFT",
+    APPLE = "APPLE"
+}
+declare enum EndUserAccountCredentialStatus {
+    ACTIVE = "ACTIVE",
+    EXPIRED = "EXPIRED",
+    REVOKED = "REVOKED"
+}
+interface EndUserAccount {
+    /** Unique identifier for the end user account */
+    id: string;
+    /** Email address of the end user */
+    email: string;
+    /** Custom ID for the end user account if provided */
+    externalId?: string | null;
+    /** The ID of the account in the provider's system, if applicable */
+    providerAccountId?: string | null;
+    /** Type of the provider associated with this end user account */
+    providerType: ProviderType;
+    /** Identifier of the application associated with this end user account */
+    applicationId: string;
+    /** List of authorized scopes granted by the end user account to the application */
+    authorizedScopes?: string[];
+    /** Status of the end user account */
+    status: EndUserAccountCredentialStatus;
+    /** Timestamp of when the end user account was created */
+    createdAt: string;
+    /** Timestamp of when the end user account was last updated */
+    updatedAt: string;
+}
+interface EndUserAccountCredential {
+    /** Unique identifier for the credential */
+    id: string;
+    /** ID of the end user account this credential belongs to */
+    endUserAccountId: string;
+    /** OAuth access token for API calls */
+    accessToken: string;
+    /** OAuth refresh token for obtaining new access tokens (null if not available) */
+    refreshToken: string | null;
+    /** Current status of the credential */
+    status: EndUserAccountCredentialStatus;
+    /** Expiration timestamp for the access token in ISO 8601 format (optional) */
+    expiresAt?: string | null;
+    /** Timestamp when the credential was created in ISO 8601 format */
+    createdAt: string;
+    /** Timestamp when the credential was last updated in ISO 8601 format */
+    updatedAt: string;
+}
+interface CreateEndUserAccountInput {
+    /** Email address of the end user */
+    email: string;
+    /** OAuth refresh token obtained from the authorization flow */
+    refreshToken: string;
+    /** Type of the provider (GOOGLE, MICROSOFT, or APPLE) */
+    providerType: ProviderType;
+    /** Custom ID for the end user account if provided */
+    externalId?: string;
+    /** List of OAuth scopes that were authorized (optional) */
+    authorizedScopes?: string[];
+}
+interface ListEndUserAccountsParams {
+    /** Pagination token for retrieving the next page of results */
+    pageToken?: string;
+    /** Maximum number of accounts to return per page */
+    limit?: number;
+    /** Filter end user accounts by email or external ID */
+    search?: string;
+    /** Filter end user accounts by status. If not provided, all EUAs matching the search parameter will be returned, regardless of status */
+    statusFilter?: 'active' | 'expired';
+}
+interface ListEndUserAccountsResponse {
+    /** Array of end user accounts */
+    data: EndUserAccount[];
+    /** Token for retrieving the next page of results */
+    nextPageToken?: string;
+}
+
+/**
+ * Free/Busy types
+ */
+
+interface BusySlot {
+    /** Start date and time of the busy period */
+    start?: EventDateTime;
+    /** End date and time of the busy period */
+    end?: EventDateTime;
+}
+interface FreeBusySlot {
+    /** ID of the calendar these busy slots belong to */
+    calendarId: string;
+    /** Array of time slots when the calendar is busy */
+    busySlots?: BusySlot[];
+}
+type FreeBusyResponse = FreeBusySlot[];
+interface GetFreeBusyInput {
+    /** ISO 8601 date-time representing the start of the time range to retrieve free/busy information for */
+    startDateTime: Date | string;
+    /** ISO 8601 date-time representing the end of the time range to retrieve free/busy information for */
+    endDateTime: Date | string;
+    /** Display all dates in the specified time zone */
+    timeZone: string;
+    /** Calendar IDs to retrieve free/busy information for */
+    calendarIds: string[];
+}
+
+/**
+ * OAuth types
+ */
+
+interface OAuthAuthorizeParams {
+    /** URL to redirect to after authorization completes */
+    redirectUrl?: string;
+    /** External identifier from your system to associate with this authorization */
+    externalId?: string;
+    /** Email hint to pre-fill the login form */
+    loginHint?: string;
+    /** OAuth prompt parameter */
+    prompt?: string;
+    /** State parameter */
+    state?: string;
+}
+interface OAuthAuthorizeUrlOptions {
+    /** Your application ID */
+    appId: string;
+    /** Calendar provider to authorize with */
+    provider: ProviderType;
+    /** Additional OAuth parameters */
+    params?: OAuthAuthorizeParams;
+}
+
+/**
+ * Calendar Subscription types
+ */
+interface CalendarSubscription {
+    /** Unique identifier for the calendar subscription */
+    id: string;
+    /** ID of the end user account that owns this subscription */
+    endUserAccountId: string;
+    /** ID of the calendar being subscribed to (optional in case subscription is for all calendars) */
+    calendarId?: string | null;
+    /** URL where webhook notifications will be sent */
+    url: string;
+    /** Calendar provider */
+    provider: string;
+    /** Expiration date/time of the subscription in ISO 8601 format (optional) */
+    expiration?: string | null;
+    /** Provider-specific subscription identifier (optional) */
+    subscriptionId?: string | null;
+    /** Provider-specific resource identifier (optional) */
+    resourceId?: string | null;
+    /** Timestamp when the subscription was created in ISO 8601 format */
+    createdAt: string;
+    /** Timestamp when the subscription was last updated in ISO 8601 format */
+    updatedAt: string;
+}
+interface CreateCalendarSubscriptionInput {
+    /** The unique identifier of the Calendar to subscribe to (Optional, required for event subscriptions) */
+    calendarId?: string;
+    /** The URL where webhook notifications will be sent. Must be a valid HTTPS URL (Required) */
+    webhookUrl: string;
+    /** Rate limit for webhook delivery (messages per second). Minimum value is 1 (Optional, if not provided there will be no rate limit applied) */
+    rateLimit?: number;
+    /** Type of subscription: 'calendar' for calendar changes or 'event' for event changes (Required) */
+    subscriptionType: 'calendar' | 'event';
+}
+interface CreateCalendarSubscriptionResponse {
+    /** Unique identifier for the created webhook subscription */
+    webhookSubscriptionId: string;
+    /** Secret key for verifying webhook payload signatures */
+    endpointSecret: string;
+}
+interface ListCalendarSubscriptionsParams {
+    /** Pagination token for retrieving the next page of results */
+    pageToken?: string;
+    /** Maximum number of subscriptions to return per page */
+    limit?: number;
+}
+
+/**
+ * Base HTTP client for making API requests
+ */
+
+declare class BaseClient {
+    private client;
+    private config;
+    constructor(config: UnifiedCalendarApiConfig);
+    private setupInterceptors;
+    get<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    put<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    patch<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    delete<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    buildUrl(path: string, params?: Record<string, any>): string;
+}
+
+/**
+ * Calendars resource client
+ */
+
+declare class Calendars {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * List all calendars for an end user account
+     * @param endUserAccountId - The end user account ID
+     * @param params - Optional pagination and filter parameters
+     */
+    list(endUserAccountId: string, params?: ListCalendarsParams): Promise<PaginatedResponse<Calendar>>;
+    /**
+     * Get a specific calendar by ID
+     * @param endUserAccountId - The end user account ID
+     * @param calendarId - The calendar ID
+     */
+    get(endUserAccountId: string, calendarId: string): Promise<Calendar>;
+    /**
+     * Create a new calendar
+     * @param endUserAccountId - The end user account ID
+     * @param data - Calendar creation data
+     */
+    create(endUserAccountId: string, data: CreateCalendarInput): Promise<Calendar>;
+    /**
+     * Update a calendar
+     * @param endUserAccountId - The end user account ID
+     * @param calendarId - The calendar ID
+     * @param data - Calendar update data
+     */
+    update(endUserAccountId: string, calendarId: string, data: UpdateCalendarInput): Promise<Calendar>;
+    /**
+     * Delete a calendar
+     * @param endUserAccountId - The end user account ID
+     * @param calendarId - The calendar ID
+     */
+    delete(endUserAccountId: string, calendarId: string): Promise<{
+        success: boolean;
+    }>;
+}
+
+/**
+ * Events resource client
+ */
+
+declare class Events {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * List events in a calendar
+     * @param endUserAccountId - The end user account ID
+     * @param calendarId - The calendar ID
+     * @param params - Optional filter parameters
+     */
+    list(endUserAccountId: string, calendarId: string, params?: ListEventsParams): Promise<PaginatedResponse<Event>>;
+    /**
+     * Get a specific event
+     * @param endUserAccountId - The end user account ID
+     * @param calendarId - The calendar ID
+     * @param eventId - The event ID
+     */
+    get(endUserAccountId: string, calendarId: string, eventId: string): Promise<Event>;
+    /**
+     * Create a new event
+     * @param endUserAccountId - The end user account ID
+     * @param calendarId - The calendar ID
+     * @param data - Event creation data
+     */
+    create(endUserAccountId: string, calendarId: string, data: CreateEventInput): Promise<Event>;
+    /**
+     * Update an event
+     * @param endUserAccountId - The end user account ID
+     * @param calendarId - The calendar ID
+     * @param eventId - The event ID
+     * @param data - Event update data
+     */
+    update(endUserAccountId: string, calendarId: string, eventId: string, data: UpdateEventInput): Promise<Event>;
+    /**
+     * Delete an event
+     * @param endUserAccountId - The end user account ID
+     * @param calendarId - The calendar ID
+     * @param eventId - The event ID
+     */
+    delete(endUserAccountId: string, calendarId: string, eventId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Get event occurrences (for recurring events)
+     * @param endUserAccountId - The end user account ID
+     * @param calendarId - The calendar ID
+     * @param eventId - The event ID
+     * @param params - Optional filter parameters
+     */
+    getOccurrences(endUserAccountId: string, calendarId: string, eventId: string, params?: ListEventsParams): Promise<PaginatedResponse<Event>>;
+    /**
+     * RSVP to an event
+     * @param endUserAccountId - The end user account ID
+     * @param calendarId - The calendar ID
+     * @param eventId - The event ID
+     * @param data - RSVP data with attendee response
+     */
+    rsvp(endUserAccountId: string, calendarId: string, eventId: string, data: RSVPInput): Promise<Event>;
+}
+
+/**
+ * End User Accounts resource client
+ */
+
+declare class EndUserAccounts {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * List all end user accounts
+     * @param params - Optional pagination and filter parameters
+     */
+    list(params?: ListEndUserAccountsParams): Promise<ListEndUserAccountsResponse>;
+    /**
+     * Get a specific end user account
+     * @param id - The end user account ID
+     */
+    get(id: string): Promise<EndUserAccount>;
+    /**
+     * Create a new end user account with credentials
+     * @param data - End user account creation data
+     */
+    create(data: CreateEndUserAccountInput): Promise<EndUserAccount>;
+    /**
+     * Delete an end user account
+     * @param id - The end user account ID
+     */
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Get credentials for an end user account
+     * This will automatically refresh credentials if they are expired
+     * @param id - The end user account ID
+     */
+    getCredentials(id: string): Promise<EndUserAccountCredential>;
+}
+
+/**
+ * FreeBusy resource client
+ */
+
+declare class FreeBusy {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * Get free/busy information for calendars
+     * @param endUserAccountId - The end user account ID
+     * @param data - Free/busy query parameters
+     */
+    get(endUserAccountId: string, data: GetFreeBusyInput): Promise<FreeBusyResponse>;
+}
+
+/**
+ * Calendar Subscriptions resource client
+ */
+
+declare class CalendarSubscriptions {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * List calendar subscriptions for an end user account
+     * @param endUserAccountId - The end user account ID
+     * @param params - Optional pagination parameters
+     */
+    list(endUserAccountId: string, params?: ListCalendarSubscriptionsParams): Promise<{
+        data: CalendarSubscription[];
+        nextPageToken?: string;
+    }>;
+    /**
+     * Create a calendar subscription
+     * @param endUserAccountId - The end user account ID
+     * @param data - Subscription data
+     */
+    create(endUserAccountId: string, data: CreateCalendarSubscriptionInput): Promise<CreateCalendarSubscriptionResponse>;
+    /**
+     * Delete a calendar subscription
+     * @param endUserAccountId - The end user account ID
+     * @param subscriptionId - The subscription ID
+     */
+    delete(endUserAccountId: string, subscriptionId: string): Promise<{
+        success: boolean;
+    }>;
+}
+
+/**
+ * Main Unified Calendar API SDK client
+ */
+
+/**
+ * Unified Calendar API Client
+ */
+declare class UnifiedCalendarApi {
+    private baseClient;
+    /** Calendar operations */
+    readonly calendars: Calendars;
+    /** Event operations */
+    readonly events: Events;
+    /** End user account operations */
+    readonly endUserAccounts: EndUserAccounts;
+    /** Free/busy operations */
+    readonly freeBusy: FreeBusy;
+    /** Calendar subscription operations */
+    readonly calendarSubscriptions: CalendarSubscriptions;
+    /**
+     * Create a new Unified Calendar API client
+     * @param config - Configuration options
+     */
+    constructor(config: UnifiedCalendarApiConfig);
+}
+
+/**
+ * Custom error classes for the UnifiedCalendarApi SDK
+ */
+/**
+ * Base error class for all UnifiedCalendarApi SDK errors
+ */
+declare class UnifiedCalendarApiError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when an API request fails
+ */
+declare class APIRequestError extends UnifiedCalendarApiError {
+    readonly status: number;
+    readonly code?: string;
+    readonly details?: Record<string, any>;
+    constructor(message: string, status: number, code?: string, details?: Record<string, any>);
+}
+/**
+ * Error thrown when input validation fails
+ */
+declare class ValidationError extends UnifiedCalendarApiError {
+    readonly errors: Record<string, string>;
+    constructor(message: string, errors?: Record<string, string>);
+}
+/**
+ * Error thrown when authentication fails
+ */
+declare class AuthenticationError extends APIRequestError {
+    constructor(message?: string);
+}
+/**
+ * Error thrown when authorization fails
+ */
+declare class AuthorizationError extends APIRequestError {
+    constructor(message?: string);
+}
+/**
+ * Error thrown when a resource is not found
+ */
+declare class NotFoundError extends APIRequestError {
+    constructor(message?: string);
+}
+/**
+ * Error thrown when rate limit is exceeded
+ */
+declare class RateLimitError extends APIRequestError {
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+
+export { type APIError, APIRequestError, type APIResponse, AuthenticationError, AuthorizationError, type BusySlot, type Calendar, type CalendarSubscription, CalendarSubscriptions, Calendars, type ConferenceData, type CreateCalendarInput, type CreateCalendarSubscriptionInput, type CreateCalendarSubscriptionResponse, type CreateEndUserAccountInput, type CreateEventInput, type EndUserAccount, type EndUserAccountCredential, EndUserAccountCredentialStatus, EndUserAccounts, type Event, type EventActor, type EventAttendee, EventColorId, type EventDateTime, EventOrderBy, type EventReminder, type EventReminders, Events, FreeBusy, type FreeBusyResponse, type FreeBusySlot, type GetFreeBusyInput, type ListCalendarSubscriptionsParams, type ListCalendarsParams, type ListEndUserAccountsParams, type ListEndUserAccountsResponse, type ListEventsParams, NotFoundError, type OAuthAuthorizeParams, type OAuthAuthorizeUrlOptions, type PaginatedResponse, type PaginationParams, ProviderType, type RSVPInput, RateLimitError, UnifiedCalendarApi, type UnifiedCalendarApiConfig, UnifiedCalendarApiError, type UpdateCalendarInput, type UpdateEventInput, ValidationError };