@jbctechsolutions/mcp-office365 2.5.1

package/dist/graph/repository.d.ts

@@ -0,0 +1,1104 @@
+/**
+ * Copyright (c) 2026 JBC Tech Solutions, LLC
+ * Licensed under the MIT License. See LICENSE file in the project root.
+ */
+/**
+ * Microsoft Graph API repository implementation.
+ *
+ * Implements the IRepository interface using Microsoft Graph API
+ * for data access instead of AppleScript or SQLite.
+ */
+import type { IRepository, FolderRow, EmailRow, EventRow, ContactRow, TaskRow, NoteRow } from '../database/repository.js';
+import { GraphClient } from './client/index.js';
+import type { DeviceCodeCallback } from './auth/index.js';
+import type { PlanVisualizationData } from '../visualization/types.js';
+/**
+ * Repository implementation using Microsoft Graph API.
+ *
+ * Provides read-only access to Outlook data via the Graph API.
+ */
+export declare class GraphRepository implements IRepository {
+    private readonly client;
+    private readonly deltaLinks;
+    private readonly idCache;
+    constructor(deviceCodeCallback?: DeviceCodeCallback);
+    listFolders(): FolderRow[];
+    listFoldersAsync(): Promise<FolderRow[]>;
+    getFolder(_id: number): FolderRow | undefined;
+    getFolderAsync(id: number): Promise<FolderRow | undefined>;
+    listEmails(_folderId: number, _limit: number, _offset: number): EmailRow[];
+    listEmailsAsync(folderId: number, limit: number, offset: number): Promise<EmailRow[]>;
+    private listEmailsWithGraphId;
+    listUnreadEmails(_folderId: number, _limit: number, _offset: number): EmailRow[];
+    listUnreadEmailsAsync(folderId: number, limit: number, offset: number): Promise<EmailRow[]>;
+    private listUnreadEmailsWithGraphId;
+    searchEmails(_query: string, _limit: number): EmailRow[];
+    searchEmailsAsync(query: string, limit: number): Promise<EmailRow[]>;
+    searchEmailsInFolder(_folderId: number, _query: string, _limit: number): EmailRow[];
+    searchEmailsInFolderAsync(folderId: number, query: string, limit: number): Promise<EmailRow[]>;
+    private searchEmailsInFolderWithGraphId;
+    /**
+     * Advanced search using raw KQL query syntax.
+     */
+    searchEmailsAdvancedAsync(query: string, limit: number): Promise<EmailRow[]>;
+    /**
+     * Advanced search in a specific folder using raw KQL query syntax.
+     */
+    searchEmailsAdvancedInFolderAsync(folderId: number, query: string, limit: number): Promise<EmailRow[]>;
+    checkNewEmailsAsync(folderId: number): Promise<{
+        emails: EmailRow[];
+        isInitialSync: boolean;
+    }>;
+    getEmail(_id: number): EmailRow | undefined;
+    /**
+     * Populates the message ID cache by listing messages from mail folders.
+     * Used as a fallback when getEmailAsync is called with an ID not yet in cache
+     * (e.g. after server restart or when list_emails/search_emails wasn't called first).
+     */
+    private refreshMessageCacheForGetEmail;
+    getEmailAsync(id: number): Promise<EmailRow | undefined>;
+    getUnreadCount(): number;
+    getUnreadCountAsync(): Promise<number>;
+    getUnreadCountByFolder(_folderId: number): number;
+    getUnreadCountByFolderAsync(folderId: number): Promise<number>;
+    /**
+     * Lists all messages in a conversation thread.
+     *
+     * Looks up the message to get its conversationId, resolves the Graph string
+     * conversationId from cache, then queries for all messages with that ID.
+     */
+    listConversationAsync(messageId: number, limit: number): Promise<EmailRow[]>;
+    listCalendars(): FolderRow[];
+    listCalendarsAsync(): Promise<FolderRow[]>;
+    listEvents(_limit: number): EventRow[];
+    listEventsAsync(limit: number): Promise<EventRow[]>;
+    listEventsByFolder(_folderId: number, _limit: number): EventRow[];
+    listEventsByFolderAsync(folderId: number, limit: number): Promise<EventRow[]>;
+    searchEvents(_query: string | null, _startDate: string | null, _endDate: string | null, _limit: number): EventRow[];
+    searchEventsAsync(query: string | null, startDate: string | null, endDate: string | null, limit: number): Promise<EventRow[]>;
+    listEventsByDateRange(_startDate: number, _endDate: number, _limit: number): EventRow[];
+    listEventsByDateRangeAsync(startDate: number, endDate: number, limit: number): Promise<EventRow[]>;
+    getEvent(_id: number): EventRow | undefined;
+    getEventAsync(id: number): Promise<EventRow | undefined>;
+    listEventInstancesAsync(eventId: number, startDate: string, endDate: string): Promise<EventRow[]>;
+    listContacts(_limit: number, _offset: number): ContactRow[];
+    listContactsAsync(limit: number, offset: number): Promise<ContactRow[]>;
+    searchContacts(_query: string, _limit: number): ContactRow[];
+    searchContactsAsync(query: string, limit: number): Promise<ContactRow[]>;
+    getContact(_id: number): ContactRow | undefined;
+    getContactAsync(id: number): Promise<ContactRow | undefined>;
+    listContactFoldersAsync(): Promise<Array<{
+        id: number;
+        name: string;
+        parentFolderId: string | null;
+    }>>;
+    createContactFolderAsync(name: string): Promise<number>;
+    deleteContactFolderAsync(folderId: number): Promise<void>;
+    listContactsInFolderAsync(folderId: number, limit?: number): Promise<ContactRow[]>;
+    getContactPhotoAsync(contactId: number): Promise<{
+        filePath: string;
+        contentType: string;
+    }>;
+    setContactPhotoAsync(contactId: number, filePath: string): Promise<void>;
+    listTasks(_limit: number, _offset: number): TaskRow[];
+    listTasksAsync(limit: number, offset: number): Promise<TaskRow[]>;
+    listIncompleteTasks(_limit: number, _offset: number): TaskRow[];
+    listIncompleteTasksAsync(limit: number, offset: number): Promise<TaskRow[]>;
+    searchTasks(_query: string, _limit: number): TaskRow[];
+    searchTasksAsync(query: string, limit: number): Promise<TaskRow[]>;
+    getTask(_id: number): TaskRow | undefined;
+    getTaskAsync(id: number): Promise<TaskRow | undefined>;
+    listTaskListsAsync(): Promise<Array<{
+        id: number;
+        name: string;
+        isDefault: boolean;
+    }>>;
+    listNotes(_limit: number, _offset: number): NoteRow[];
+    listNotesAsync(_limit: number, _offset: number): Promise<NoteRow[]>;
+    getNote(_id: number): NoteRow | undefined;
+    getNoteAsync(_id: number): Promise<NoteRow | undefined>;
+    /**
+     * Gets the Graph client instance for direct access if needed.
+     */
+    getClient(): GraphClient;
+    /**
+     * Returns the Graph client (satisfies IMailSendRepository).
+     */
+    getGraphClient(): GraphClient;
+    /**
+     * Returns the Graph string ID for a cached draft numeric ID (satisfies IMailSendRepository).
+     */
+    getGraphIdForDraft(draftId: number): string | undefined;
+    /**
+     * Gets the Graph string ID from a numeric ID.
+     */
+    getGraphId(type: 'folder' | 'message' | 'event' | 'contact', numericId: number): string | undefined;
+    /**
+     * Gets task info from a numeric ID.
+     */
+    getTaskInfo(numericId: number): {
+        taskListId: string;
+        taskId: string;
+    } | undefined;
+    /**
+     * Gets the Graph string ID for a task list from a numeric ID.
+     */
+    getTaskListGraphId(numericId: number): string | undefined;
+    moveEmail(_emailId: number, _destinationFolderId: number): void;
+    deleteEmail(_emailId: number): void;
+    archiveEmail(_emailId: number): void;
+    junkEmail(_emailId: number): void;
+    markEmailRead(_emailId: number, _isRead: boolean): void;
+    setEmailFlag(_emailId: number, _flagStatus: number): void;
+    setEmailCategories(_emailId: number, _categories: string[]): void;
+    setEmailImportance(_emailId: number, _importance: string): void;
+    createFolder(_name: string, _parentFolderId?: number): FolderRow;
+    deleteFolder(_folderId: number): void;
+    renameFolder(_folderId: number, _newName: string): void;
+    moveFolder(_folderId: number, _destinationParentId: number): void;
+    emptyFolder(_folderId: number): void;
+    moveEmailAsync(emailId: number, destinationFolderId: number): Promise<void>;
+    deleteEmailAsync(emailId: number): Promise<void>;
+    archiveEmailAsync(emailId: number): Promise<void>;
+    junkEmailAsync(emailId: number): Promise<void>;
+    markEmailReadAsync(emailId: number, isRead: boolean): Promise<void>;
+    setEmailFlagAsync(emailId: number, flagStatus: number): Promise<void>;
+    setEmailCategoriesAsync(emailId: number, categories: string[]): Promise<void>;
+    setEmailImportanceAsync(emailId: number, importance: string): Promise<void>;
+    createFolderAsync(name: string, parentFolderId?: number): Promise<FolderRow>;
+    deleteFolderAsync(folderId: number): Promise<void>;
+    renameFolderAsync(folderId: number, newName: string): Promise<void>;
+    moveFolderAsync(folderId: number, destinationParentId: number): Promise<void>;
+    emptyFolderAsync(folderId: number): Promise<void>;
+    /**
+     * Creates a new draft message.
+     *
+     * Converts email address strings to Recipient objects, calls the Graph client,
+     * adds the returned draft to idCache.messages, and returns its numeric ID.
+     */
+    createDraftAsync(params: {
+        subject: string;
+        body: string;
+        bodyType: 'text' | 'html';
+        to?: string[];
+        cc?: string[];
+        bcc?: string[];
+    }): Promise<{
+        numericId: number;
+        graphId: string;
+    }>;
+    /**
+     * Updates an existing draft message.
+     *
+     * Looks up the Graph string ID from idCache.messages, then calls the client.
+     */
+    updateDraftAsync(draftId: number, updates: Record<string, unknown>): Promise<void>;
+    /**
+     * Lists draft messages.
+     *
+     * Uses the well-known 'drafts' folder name directly with the Graph API.
+     */
+    listDraftsAsync(limit: number, offset: number): Promise<EmailRow[]>;
+    /**
+     * Sends an existing draft message.
+     *
+     * Looks up the Graph string ID from idCache.messages, then calls the client.
+     */
+    sendDraftAsync(draftId: number): Promise<void>;
+    /**
+     * Sends a new email directly without creating a draft first.
+     *
+     * Converts email address strings to Recipient objects and calls the client.
+     */
+    sendMailAsync(params: {
+        subject: string;
+        body: string;
+        bodyType: 'text' | 'html';
+        to: string[];
+        cc?: string[];
+        bcc?: string[];
+    }): Promise<void>;
+    /**
+     * Replies to a message (or replies all).
+     *
+     * Looks up the Graph string ID from idCache.messages, then calls the client.
+     */
+    replyMessageAsync(messageId: number, comment: string, replyAll: boolean): Promise<void>;
+    /**
+     * Forwards a message to specified recipients.
+     *
+     * Looks up the Graph string ID from idCache.messages, converts recipient
+     * email strings to Recipient objects, then calls the client.
+     */
+    forwardMessageAsync(messageId: number, toRecipients: string[], comment?: string): Promise<void>;
+    /**
+     * Creates a reply (or reply-all) draft for a message.
+     *
+     * Looks up the Graph string ID from idCache.messages, creates the draft
+     * via the client, caches the new draft ID, and optionally updates the body.
+     *
+     * @returns The numeric and graph IDs of the new draft.
+     */
+    replyAsDraftAsync(messageId: number, replyAll?: boolean, comment?: string, bodyType?: string): Promise<{
+        numericId: number;
+        graphId: string;
+    }>;
+    /**
+     * Creates a forward draft for a message.
+     *
+     * Looks up the Graph string ID from idCache.messages, creates the draft
+     * via the client, caches the new draft ID, and optionally updates the
+     * recipients and body.
+     *
+     * @returns The numeric and graph IDs of the new draft.
+     */
+    forwardAsDraftAsync(messageId: number, toRecipients?: string[], comment?: string, bodyType?: string): Promise<{
+        numericId: number;
+        graphId: string;
+    }>;
+    getScheduleAsync(params: {
+        emailAddresses: string[];
+        startTime: string;
+        endTime: string;
+        availabilityViewInterval?: number;
+    }): Promise<unknown[]>;
+    findMeetingTimesAsync(params: {
+        attendees: string[];
+        durationMinutes: number;
+        startTime?: string;
+        endTime?: string;
+        maxCandidates?: number;
+    }): Promise<unknown>;
+    /**
+     * Lists attachments for a given email.
+     *
+     * Looks up the Graph message ID from idCache.messages, calls
+     * client.listAttachments, hashes each attachment ID to a numeric key,
+     * and caches it in idCache.attachments with { messageId, attachmentId }.
+     *
+     * @returns Array of attachment metadata objects.
+     */
+    listAttachmentsAsync(emailId: number): Promise<Array<{
+        id: number;
+        name: string;
+        size: number;
+        contentType: string;
+        isInline: boolean;
+    }>>;
+    /**
+     * Downloads an attachment for a given email.
+     *
+     * Looks up { messageId, attachmentId } from idCache.attachments,
+     * then delegates to the downloadAttachment helper which fetches
+     * the content and writes it to disk.
+     *
+     * @returns Metadata about the downloaded file including its local path.
+     */
+    downloadAttachmentAsync(attachmentId: number): Promise<{
+        filePath: string;
+        name: string;
+        size: number;
+        contentType: string;
+    }>;
+    /**
+     * Creates a new calendar event.
+     *
+     * Builds a Graph API event object from the given params, calls
+     * client.createEvent(), adds the result to idCache.events, and
+     * returns the numeric ID.
+     */
+    createEventAsync(params: {
+        subject: string;
+        start: string;
+        end: string;
+        timezone?: string;
+        location?: string;
+        body?: string;
+        bodyType?: 'text' | 'html';
+        attendees?: Array<{
+            email: string;
+            name?: string;
+            type?: 'required' | 'optional';
+        }>;
+        isAllDay?: boolean;
+        recurrence?: {
+            pattern: {
+                type: 'daily' | 'weekly' | 'monthly' | 'yearly';
+                interval: number;
+                daysOfWeek?: string[];
+            };
+            range: {
+                type: 'endDate' | 'noEnd' | 'numbered';
+                startDate: string;
+                endDate?: string;
+                numberOfOccurrences?: number;
+            };
+        };
+        calendarId?: number;
+        is_online_meeting?: boolean;
+        online_meeting_provider?: string;
+    }): Promise<number>;
+    /**
+     * Updates an existing calendar event.
+     *
+     * Looks up the Graph string ID from idCache.events, then calls
+     * client.updateEvent(). Throws if the event is not cached.
+     */
+    updateEventAsync(eventId: number, updates: Record<string, unknown>): Promise<void>;
+    /**
+     * Deletes a calendar event.
+     *
+     * Looks up the Graph string ID from idCache.events, calls
+     * client.deleteEvent(), and removes the entry from idCache.
+     * Throws if the event is not cached.
+     */
+    deleteEventAsync(eventId: number): Promise<void>;
+    /**
+     * Responds to a calendar event invitation.
+     *
+     * Looks up the Graph string ID from idCache.events, then calls
+     * client.respondToEvent(). Throws if the event is not cached.
+     */
+    respondToEventAsync(eventId: number, response: 'accept' | 'decline' | 'tentative', sendResponse: boolean, comment?: string): Promise<void>;
+    /**
+     * Creates a new contact.
+     *
+     * Maps snake_case input fields to Graph API camelCase fields, calls
+     * client.createContact(), caches the resulting ID, and returns a numeric ID.
+     */
+    createContactAsync(params: {
+        given_name?: string;
+        surname?: string;
+        email?: string;
+        phone?: string;
+        mobile_phone?: string;
+        company?: string;
+        job_title?: string;
+        street_address?: string;
+        city?: string;
+        state?: string;
+        postal_code?: string;
+        country?: string;
+    }): Promise<number>;
+    /**
+     * Updates an existing contact.
+     *
+     * Looks up the Graph string ID from idCache.contacts, then calls
+     * client.updateContact(). Throws if the contact is not cached.
+     */
+    updateContactAsync(contactId: number, updates: Record<string, unknown>): Promise<void>;
+    /**
+     * Deletes a contact.
+     *
+     * Looks up the Graph string ID from idCache.contacts, calls
+     * client.deleteContact(), and removes the entry from idCache.
+     * Throws if the contact is not cached.
+     */
+    deleteContactAsync(contactId: number): Promise<void>;
+    /**
+     * Creates a new task in a task list.
+     *
+     * Looks up the Graph task list ID from idCache.taskLists, builds a
+     * Graph API task object from the given params, calls client.createTask(),
+     * caches the resulting ID, and returns a numeric ID.
+     */
+    createTaskAsync(params: {
+        title: string;
+        task_list_id: number;
+        body?: string;
+        body_type?: 'text' | 'html';
+        due_date?: string;
+        importance?: 'low' | 'normal' | 'high';
+        reminder_date?: string;
+        recurrence?: {
+            pattern: 'daily' | 'weekly' | 'monthly' | 'yearly';
+            interval?: number | undefined;
+            days_of_week?: string[] | undefined;
+            day_of_month?: number | undefined;
+            range_type: 'endDate' | 'noEnd' | 'numbered';
+            start_date: string;
+            end_date?: string | undefined;
+            occurrences?: number | undefined;
+        } | undefined;
+        categories?: string[];
+    }): Promise<number>;
+    /**
+     * Updates an existing task.
+     *
+     * Looks up the Graph task info from idCache.tasks, then calls
+     * client.updateTask(). Throws if the task is not cached.
+     */
+    updateTaskAsync(taskId: number, updates: Record<string, unknown>): Promise<void>;
+    /**
+     * Marks a task as completed.
+     *
+     * Convenience method that calls updateTaskAsync with status: 'completed'
+     * and the current time as completedDateTime.
+     */
+    completeTaskAsync(taskId: number): Promise<void>;
+    /**
+     * Deletes a task.
+     *
+     * Looks up the Graph task info from idCache.tasks, calls
+     * client.deleteTask(), and removes the entry from idCache.
+     * Throws if the task is not cached.
+     */
+    deleteTaskAsync(taskId: number): Promise<void>;
+    /**
+     * Creates a new task list.
+     *
+     * Calls client.createTaskList(), caches the resulting ID in
+     * idCache.taskLists, and returns a numeric ID.
+     */
+    createTaskListAsync(displayName: string): Promise<number>;
+    /**
+     * Renames a task list.
+     */
+    renameTaskListAsync(listId: number, name: string): Promise<void>;
+    /**
+     * Deletes a task list.
+     */
+    deleteTaskListAsync(listId: number): Promise<void>;
+    listChecklistItemsAsync(taskId: number): Promise<Array<{
+        id: number;
+        displayName: string;
+        isChecked: boolean;
+        createdDateTime: string;
+    }>>;
+    createChecklistItemAsync(taskId: number, displayName: string, isChecked?: boolean): Promise<number>;
+    updateChecklistItemAsync(checklistItemId: number, updates: {
+        displayName?: string;
+        isChecked?: boolean;
+    }): Promise<void>;
+    deleteChecklistItemAsync(checklistItemId: number): Promise<void>;
+    listLinkedResourcesAsync(taskId: number): Promise<Array<{
+        id: number;
+        webUrl: string;
+        applicationName: string;
+        displayName: string;
+    }>>;
+    createLinkedResourceAsync(taskId: number, webUrl: string, applicationName: string, displayName?: string): Promise<number>;
+    deleteLinkedResourceAsync(linkedResourceId: number): Promise<void>;
+    listTaskAttachmentsAsync(taskId: number): Promise<Array<{
+        id: number;
+        name: string;
+        size: number;
+        contentType: string;
+    }>>;
+    createTaskAttachmentAsync(taskId: number, name: string, contentBytes: string, contentType?: string): Promise<number>;
+    deleteTaskAttachmentAsync(taskAttachmentId: number): Promise<void>;
+    /**
+     * Lists all inbox mail rules.
+     */
+    listMailRulesAsync(): Promise<Array<{
+        id: number;
+        displayName: string;
+        sequence: number;
+        isEnabled: boolean;
+        conditions: unknown;
+        actions: unknown;
+    }>>;
+    /**
+     * Creates a new inbox mail rule.
+     */
+    createMailRuleAsync(rule: Record<string, unknown>): Promise<number>;
+    /**
+     * Deletes an inbox mail rule.
+     */
+    deleteMailRuleAsync(ruleId: number): Promise<void>;
+    /**
+     * Gets the current automatic replies (OOF) settings.
+     */
+    getAutomaticRepliesAsync(): Promise<{
+        status: string;
+        externalAudience: string;
+        internalReplyMessage: string;
+        externalReplyMessage: string;
+        scheduledStartDateTime: string | null;
+        scheduledEndDateTime: string | null;
+    }>;
+    /**
+     * Sets the automatic replies (OOF) settings.
+     */
+    setAutomaticRepliesAsync(params: {
+        status: 'disabled' | 'alwaysEnabled' | 'scheduled';
+        externalAudience?: 'none' | 'contactsOnly' | 'all';
+        internalReplyMessage?: string;
+        externalReplyMessage?: string;
+        scheduledStartDateTime?: string;
+        scheduledEndDateTime?: string;
+    }): Promise<void>;
+    /**
+     * Gets the current mailbox settings (language, time zone, formats, working hours).
+     */
+    getMailboxSettingsAsync(): Promise<{
+        language: string | null;
+        timeZone: string | null;
+        dateFormat: string | null;
+        timeFormat: string | null;
+        workingHours: unknown;
+    }>;
+    /**
+     * Updates mailbox settings (language, time zone, date/time formats).
+     */
+    updateMailboxSettingsAsync(params: {
+        language?: string;
+        timeZone?: string;
+        dateFormat?: string;
+        timeFormat?: string;
+    }): Promise<void>;
+    /**
+     * Lists all master categories.
+     */
+    listCategoriesAsync(): Promise<Array<{
+        id: number;
+        name: string;
+        color: string;
+    }>>;
+    /**
+     * Creates a new master category.
+     */
+    createCategoryAsync(name: string, color: string): Promise<number>;
+    /**
+     * Deletes a master category.
+     */
+    deleteCategoryAsync(categoryId: number): Promise<void>;
+    /**
+     * Lists all focused inbox overrides.
+     */
+    listFocusedOverridesAsync(): Promise<Array<{
+        id: number;
+        senderAddress: string;
+        classifyAs: string;
+    }>>;
+    /**
+     * Creates a focused inbox override.
+     */
+    createFocusedOverrideAsync(senderAddress: string, classifyAs: 'focused' | 'other'): Promise<number>;
+    /**
+     * Deletes a focused inbox override.
+     */
+    deleteFocusedOverrideAsync(overrideId: number): Promise<void>;
+    /**
+     * Gets internet message headers for an email.
+     */
+    getMessageHeadersAsync(emailId: number): Promise<Array<{
+        name: string;
+        value: string;
+    }>>;
+    /**
+     * Gets the MIME content of a message and saves it as an .eml file.
+     */
+    getMessageMimeAsync(emailId: number): Promise<{
+        filePath: string;
+    }>;
+    /**
+     * Gets mail tips for the specified email addresses.
+     */
+    getMailTipsAsync(emailAddresses: string[]): Promise<Array<{
+        emailAddress: string;
+        automaticReplies: {
+            message: string;
+        } | null;
+        mailboxFull: boolean;
+        deliveryRestricted: boolean;
+        externalMemberCount: number;
+        maxMessageSize: number;
+    }>>;
+    /**
+     * Lists all calendar groups.
+     */
+    listCalendarGroupsAsync(): Promise<Array<{
+        id: number;
+        name: string;
+        classId: string;
+    }>>;
+    /**
+     * Creates a new calendar group.
+     */
+    createCalendarGroupAsync(name: string): Promise<number>;
+    /**
+     * Lists all permissions for a calendar.
+     */
+    listCalendarPermissionsAsync(calendarId: number): Promise<Array<{
+        id: number;
+        emailAddress: string;
+        role: string;
+        isRemovable: boolean;
+        isInsideOrganization: boolean;
+    }>>;
+    /**
+     * Creates a calendar permission (shares a calendar with someone).
+     */
+    createCalendarPermissionAsync(calendarId: number, email: string, role: string): Promise<number>;
+    /**
+     * Deletes a calendar permission.
+     */
+    deleteCalendarPermissionAsync(permissionId: number): Promise<void>;
+    /**
+     * Lists all room lists.
+     */
+    listRoomListsAsync(): Promise<Array<{
+        name: string;
+        address: string;
+    }>>;
+    /**
+     * Lists rooms, optionally filtered by a room list email.
+     */
+    listRoomsAsync(roomListEmail?: string): Promise<Array<{
+        name: string;
+        address: string;
+    }>>;
+    /**
+     * Lists all joined teams with cached numeric IDs.
+     */
+    listTeamsAsync(): Promise<Array<{
+        id: number;
+        name: string;
+        description: string;
+    }>>;
+    /**
+     * Lists all channels in a team with cached numeric IDs.
+     */
+    listChannelsAsync(teamId: number): Promise<Array<{
+        id: number;
+        name: string;
+        description: string;
+        membershipType: string;
+    }>>;
+    /**
+     * Gets a specific channel by cached numeric ID.
+     */
+    getChannelAsync(channelId: number): Promise<{
+        id: number;
+        name: string;
+        description: string;
+        membershipType: string;
+        webUrl: string;
+    }>;
+    /**
+     * Creates a new channel in a team.
+     */
+    createChannelAsync(teamId: number, name: string, description?: string): Promise<number>;
+    /**
+     * Updates a channel's properties.
+     */
+    updateChannelAsync(channelId: number, updates: {
+        name?: string;
+        description?: string;
+    }): Promise<void>;
+    /**
+     * Deletes a channel.
+     */
+    deleteChannelAsync(channelId: number): Promise<void>;
+    /**
+     * Lists members of a team.
+     */
+    listTeamMembersAsync(teamId: number): Promise<Array<{
+        id: string;
+        displayName: string;
+        email: string;
+        roles: string[];
+    }>>;
+    /**
+     * Lists recent messages in a channel.
+     */
+    listChannelMessagesAsync(channelId: number, limit?: number): Promise<Array<{
+        id: number;
+        senderName: string;
+        senderEmail: string;
+        bodyPreview: string;
+        bodyContent: string;
+        contentType: string;
+        createdDateTime: string;
+    }>>;
+    /**
+     * Gets a specific channel message with its replies.
+     */
+    getChannelMessageAsync(messageId: number): Promise<{
+        id: number;
+        senderName: string;
+        senderEmail: string;
+        bodyContent: string;
+        contentType: string;
+        createdDateTime: string;
+        replies: Array<{
+            id: number;
+            senderName: string;
+            senderEmail: string;
+            bodyContent: string;
+            contentType: string;
+            createdDateTime: string;
+        }>;
+    }>;
+    /**
+     * Sends a new message to a channel.
+     */
+    sendChannelMessageAsync(channelId: number, body: string, contentType?: string): Promise<number>;
+    /**
+     * Replies to a channel message.
+     */
+    replyToChannelMessageAsync(messageId: number, body: string, contentType?: string): Promise<number>;
+    listChatsAsync(limit?: number): Promise<Array<{
+        id: number;
+        topic: string;
+        chatType: string;
+        lastMessagePreview: string;
+        createdDateTime: string;
+    }>>;
+    getChatAsync(chatId: number): Promise<{
+        id: number;
+        topic: string;
+        chatType: string;
+        createdDateTime: string;
+        webUrl: string;
+    }>;
+    listChatMessagesAsync(chatId: number, limit?: number): Promise<Array<{
+        id: number;
+        senderName: string;
+        senderEmail: string;
+        bodyPreview: string;
+        bodyContent: string;
+        contentType: string;
+        createdDateTime: string;
+    }>>;
+    sendChatMessageAsync(chatId: number, body: string, contentType?: string): Promise<number>;
+    listMessageReactionsAsync(messageId: number, messageType: 'channel' | 'chat'): Promise<Array<{
+        reactionType: string;
+        user: {
+            displayName: string;
+        };
+        createdDateTime: string;
+    }>>;
+    addMessageReactionAsync(messageId: number, messageType: 'channel' | 'chat', reactionType: string): Promise<void>;
+    removeMessageReactionAsync(messageId: number, messageType: 'channel' | 'chat', reactionType: string): Promise<void>;
+    listChatMembersAsync(chatId: number): Promise<Array<{
+        displayName: string;
+        email: string;
+        roles: string[];
+    }>>;
+    /**
+     * Lists all plans the current user has.
+     */
+    listPlansAsync(): Promise<Array<{
+        id: number;
+        title: string;
+        owner: string;
+        createdDateTime: string;
+    }>>;
+    /**
+     * Gets a specific plan by cached numeric ID.
+     */
+    getPlanAsync(planId: number): Promise<{
+        id: number;
+        title: string;
+        owner: string;
+        createdDateTime: string;
+        etag: string;
+    }>;
+    /**
+     * Creates a new plan.
+     */
+    createPlanAsync(title: string, groupId: string): Promise<number>;
+    /**
+     * Updates a plan (requires cached ETag).
+     */
+    updatePlanAsync(planId: number, updates: {
+        title?: string;
+    }): Promise<void>;
+    /**
+     * Lists all buckets in a plan.
+     */
+    listBucketsAsync(planId: number): Promise<Array<{
+        id: number;
+        name: string;
+        planId: number;
+        orderHint: string;
+    }>>;
+    /**
+     * Creates a new bucket in a plan.
+     */
+    createBucketAsync(planId: number, name: string): Promise<number>;
+    /**
+     * Updates a bucket (requires cached ETag).
+     */
+    updateBucketAsync(bucketId: number, updates: {
+        name?: string;
+    }): Promise<void>;
+    /**
+     * Deletes a bucket (requires cached ETag).
+     */
+    deleteBucketAsync(bucketId: number): Promise<void>;
+    /**
+     * Lists all tasks in a plan.
+     */
+    listPlannerTasksAsync(planId: number): Promise<Array<{
+        id: number;
+        title: string;
+        bucketId: number | null;
+        assignees: string[];
+        percentComplete: number;
+        priority: number;
+        startDateTime: string;
+        dueDateTime: string;
+        createdDateTime: string;
+    }>>;
+    /**
+     * Gets a specific planner task by cached numeric ID.
+     */
+    getPlannerTaskAsync(taskId: number): Promise<{
+        id: number;
+        title: string;
+        bucketId: number | null;
+        assignees: string[];
+        percentComplete: number;
+        priority: number;
+        startDateTime: string;
+        dueDateTime: string;
+        createdDateTime: string;
+        conversationThreadId: string;
+        orderHint: string;
+        etag: string;
+    }>;
+    /**
+     * Creates a new planner task.
+     */
+    createPlannerTaskAsync(planId: number, title: string, bucketId?: number, assignments?: Record<string, object>, priority?: number, startDate?: string, dueDate?: string): Promise<number>;
+    /**
+     * Updates a planner task (requires cached ETag).
+     */
+    updatePlannerTaskAsync(taskId: number, updates: {
+        title?: string;
+        bucketId?: number;
+        percentComplete?: number;
+        priority?: number;
+        startDate?: string;
+        dueDate?: string;
+        assignments?: Record<string, object>;
+    }): Promise<void>;
+    /**
+     * Deletes a planner task (requires cached ETag).
+     */
+    deletePlannerTaskAsync(taskId: number): Promise<void>;
+    /**
+     * Gets details for a planner task (description, checklist, references).
+     */
+    getPlannerTaskDetailsAsync(taskId: number): Promise<{
+        id: number;
+        description: string;
+        checklist: Record<string, unknown>;
+        references: Record<string, unknown>;
+        etag: string;
+    }>;
+    /**
+     * Lists all tasks in a plan with their details (description, checklist, references)
+     * fetched in batched requests. This avoids N+1 queries when you need both the task
+     * list and each task's details.
+     *
+     * Details are fetched via the Graph $batch API (up to 20 per batch).
+     * Partial failures are handled gracefully: tasks whose detail fetch failed will
+     * have `details` set to `undefined`.
+     */
+    listPlannerTasksWithDetailsAsync(planId: number): Promise<Array<{
+        id: number;
+        title: string;
+        bucketId: number | null;
+        assignees: string[];
+        percentComplete: number;
+        priority: number;
+        startDateTime: string;
+        dueDateTime: string;
+        createdDateTime: string;
+        details?: {
+            description: string;
+            checklist: Record<string, unknown>;
+            references: Record<string, unknown>;
+            etag: string;
+        } | undefined;
+    }>>;
+    /**
+     * Updates details for a planner task (requires cached ETag from getPlannerTaskDetailsAsync).
+     */
+    updatePlannerTaskDetailsAsync(taskId: number, updates: {
+        description?: string;
+        checklist?: Record<string, object>;
+        references?: Record<string, object>;
+    }): Promise<void>;
+    /**
+     * Assembles plan, buckets, and tasks into a unified visualization data object.
+     */
+    getPlanVisualizationDataAsync(planId: number): Promise<PlanVisualizationData>;
+    listOnlineMeetingsAsync(limit?: number): Promise<Array<{
+        id: number;
+        subject: string;
+        startDateTime: string;
+        endDateTime: string;
+        joinUrl: string;
+    }>>;
+    getOnlineMeetingAsync(meetingId: number): Promise<{
+        id: number;
+        subject: string;
+        startDateTime: string;
+        endDateTime: string;
+        joinUrl: string;
+        participants: unknown;
+    } | undefined>;
+    listMeetingRecordingsAsync(meetingId: number): Promise<Array<{
+        id: number;
+        createdDateTime: string;
+        recordingContentUrl: string;
+    }>>;
+    downloadMeetingRecordingAsync(recordingId: number, outputPath: string): Promise<string>;
+    listMeetingTranscriptsAsync(meetingId: number): Promise<Array<{
+        id: number;
+        createdDateTime: string;
+        contentUrl: string;
+    }>>;
+    getMeetingTranscriptContentAsync(transcriptId: number, format?: string): Promise<string>;
+    listWorksheetsAsync(fileId: number): Promise<Record<string, unknown>[]>;
+    getWorksheetRangeAsync(fileId: number, worksheetName: string, range: string): Promise<Record<string, unknown>>;
+    getUsedRangeAsync(fileId: number, worksheetName: string): Promise<Record<string, unknown>>;
+    updateWorksheetRangeAsync(fileId: number, worksheetName: string, range: string, values: unknown[][]): Promise<Record<string, unknown>>;
+    getTableDataAsync(fileId: number, tableName: string): Promise<Record<string, unknown>[]>;
+    /**
+     * Lists files/folders in a drive folder (or root).
+     */
+    listDriveItemsAsync(folderId?: number): Promise<Array<{
+        id: number;
+        name: string;
+        size: number;
+        lastModified: string;
+        isFolder: boolean;
+        webUrl: string;
+    }>>;
+    /**
+     * Searches drive items by query.
+     */
+    searchDriveItemsAsync(query: string, limit?: number): Promise<Array<{
+        id: number;
+        name: string;
+        size: number;
+        lastModified: string;
+        isFolder: boolean;
+        webUrl: string;
+    }>>;
+    /**
+     * Gets metadata for a specific drive item.
+     */
+    getDriveItemAsync(itemId: number): Promise<{
+        id: number;
+        name: string;
+        size: number;
+        lastModified: string;
+        isFolder: boolean;
+        webUrl: string;
+        mimeType: string;
+        createdBy: string;
+    }>;
+    /**
+     * Downloads a drive item to a local file.
+     */
+    downloadFileAsync(itemId: number, outputPath: string): Promise<{
+        savedPath: string;
+        size: number;
+    }>;
+    /**
+     * Uploads a local file to OneDrive.
+     */
+    uploadFileAsync(parentPath: string, fileName: string, localFilePath: string): Promise<number>;
+    /**
+     * Lists recently accessed drive items.
+     */
+    listRecentFilesAsync(): Promise<Array<{
+        id: number;
+        name: string;
+        size: number;
+        lastModified: string;
+        isFolder: boolean;
+        webUrl: string;
+    }>>;
+    /**
+     * Lists drive items shared with the user.
+     */
+    listSharedWithMeAsync(): Promise<Array<{
+        id: number;
+        name: string;
+        size: number;
+        lastModified: string;
+        isFolder: boolean;
+        webUrl: string;
+    }>>;
+    /**
+     * Creates a sharing link for a drive item.
+     */
+    createSharingLinkAsync(itemId: number, type: string, scope: string): Promise<{
+        webUrl: string;
+        type: string;
+        scope: string;
+    }>;
+    /**
+     * Deletes a drive item.
+     */
+    deleteDriveItemAsync(itemId: number): Promise<void>;
+    /**
+     * Lists followed SharePoint sites, caching IDs.
+     */
+    listSitesAsync(): Promise<Array<{
+        id: number;
+        name: string;
+        webUrl: string;
+        displayName: string;
+    }>>;
+    /**
+     * Searches SharePoint sites by keyword, caching IDs.
+     */
+    searchSitesAsync(query: string): Promise<Array<{
+        id: number;
+        name: string;
+        webUrl: string;
+        displayName: string;
+    }>>;
+    /**
+     * Gets details for a specific SharePoint site.
+     */
+    getSiteAsync(siteId: number): Promise<{
+        id: number;
+        name: string;
+        webUrl: string;
+        displayName: string;
+        description: string;
+    }>;
+    /**
+     * Lists document libraries for a SharePoint site, caching IDs.
+     */
+    listDocumentLibrariesAsync(siteId: number): Promise<Array<{
+        id: number;
+        name: string;
+        webUrl: string;
+        driveType: string;
+    }>>;
+    /**
+     * Lists items in a document library or folder, caching IDs.
+     */
+    listLibraryItemsAsync(libraryId: number, folderId?: number): Promise<Array<{
+        id: number;
+        name: string;
+        size: number;
+        webUrl: string;
+        lastModifiedDateTime: string;
+        isFolder: boolean;
+    }>>;
+    /**
+     * Downloads a file from a document library to the specified path.
+     */
+    downloadLibraryFileAsync(itemId: number, outputPath: string): Promise<string>;
+    /**
+     * Gets the Graph string ID for a folder from the cache.
+     */
+    getFolderGraphId(folderId: number): string | undefined;
+}
+/**
+ * Creates a Microsoft Graph API repository.
+ */
+export declare function createGraphRepository(deviceCodeCallback?: DeviceCodeCallback): GraphRepository;
+//# sourceMappingURL=repository.d.ts.map