dav-mcp 3.0.0

package/src/tools/calendar/list-calendars.js

@@ -0,0 +1,21 @@
+import { tsdavManager } from '../../tsdav-client.js';
+import { formatCalendarList } from '../../formatters.js';
+
+/**
+ * List all available calendars from the CalDAV server
+ */
+export const listCalendars = {
+  name: 'list_calendars',
+  description: 'List all available calendars from the CalDAV server. Use this to get calendar URLs needed for other operations',
+  inputSchema: {
+    type: 'object',
+    properties: {},
+    required: [],
+  },
+  handler: async () => {
+    const client = tsdavManager.getCalDavClient();
+    const calendars = await client.fetchCalendars();
+
+    return formatCalendarList(calendars);
+  },
+};

package/src/tools/calendar/list-events.js

@@ -0,0 +1,43 @@
+import { tsdavManager } from '../../tsdav-client.js';
+import { validateInput, listEventsSchema } from '../../validation.js';
+import { formatEventList } from '../../formatters.js';
+import { findCalendarOrThrow, buildTimeRangeOptions } from '../shared/helpers.js';
+
+/**
+ * List ALL events from a single calendar without filtering
+ */
+export const listEvents = {
+  name: 'list_events',
+  description: 'List ALL events from a single calendar without filtering. WARNING: Returns all events which can be many thousands - use calendar_query instead for searching with filters (supports multi-calendar search).',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      calendar_url: {
+        type: 'string',
+        description: 'The URL of the calendar to fetch events from. Use list_calendars first to get available URLs.',
+      },
+      time_range_start: {
+        type: 'string',
+        description: 'Optional: Start date in ISO 8601 format (e.g., 2025-01-01T00:00:00.000Z)',
+      },
+      time_range_end: {
+        type: 'string',
+        description: 'Optional: End date in ISO 8601 format',
+      },
+    },
+    required: ['calendar_url'],
+  },
+  handler: async (args) => {
+    const validated = validateInput(listEventsSchema, args);
+    const client = tsdavManager.getCalDavClient();
+    const calendars = await client.fetchCalendars();
+    const calendar = findCalendarOrThrow(calendars, validated.calendar_url);
+
+    const timeRangeOptions = buildTimeRangeOptions(validated.time_range_start, validated.time_range_end);
+    const options = { calendar, ...timeRangeOptions };
+
+    const events = await client.fetchCalendarObjects(options);
+
+    return formatEventList(events, calendar);
+  },
+};

package/src/tools/calendar/make-calendar.js

@@ -0,0 +1,80 @@
+import { tsdavManager } from '../../tsdav-client.js';
+import { validateInput, makeCalendarSchema } from '../../validation.js';
+import { formatSuccess } from '../../formatters.js';
+import { getCalendarHome, sanitizeNameForUrl } from '../shared/helpers.js';
+
+/**
+ * Create a new calendar collection
+ */
+export const makeCalendar = {
+  name: 'make_calendar',
+  description: 'Create a new calendar collection on the CalDAV server with optional color, description, timezone, and component types',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      display_name: {
+        type: 'string',
+        description: 'Display name for the new calendar',
+      },
+      description: {
+        type: 'string',
+        description: 'Optional: Calendar description',
+      },
+      color: {
+        type: 'string',
+        description: 'Optional: Calendar color in hex format (e.g., #FF5733)',
+      },
+      timezone: {
+        type: 'string',
+        description: 'Optional: Timezone ID (e.g., Europe/Berlin)',
+      },
+      components: {
+        type: 'array',
+        items: {
+          type: 'string',
+          enum: ['VEVENT', 'VTODO', 'VJOURNAL']
+        },
+        description: 'Optional: Supported component types. Default: ["VEVENT", "VTODO"]. Use ["VEVENT"] for events only, ["VTODO"] for tasks only.',
+      },
+    },
+    required: ['display_name'],
+  },
+  handler: async (args) => {
+    const validated = validateInput(makeCalendarSchema, args);
+    const client = tsdavManager.getCalDavClient();
+
+    // Get calendar home URL
+    const calendarHome = await getCalendarHome(client);
+
+    // Generate new calendar URL with sanitized name
+    const sanitizedName = sanitizeNameForUrl(validated.display_name);
+    const newCalendarUrl = `${calendarHome}${sanitizedName}/`;
+
+    // Prepare calendar props
+    const calendarProps = {
+      displayName: validated.display_name,
+      description: validated.description,
+      calendarColor: validated.color,
+      timezone: validated.timezone,
+    };
+
+    // Add supported component set if specified
+    // NOTE: Radicale ignores this property (known limitation), but works with Nextcloud/Baikal
+    // Format: supportedCalendarComponentSet.comp[{_attributes: {name: 'VEVENT'}}]
+    if (validated.components && validated.components.length > 0) {
+      calendarProps.supportedCalendarComponentSet = {
+        comp: validated.components.map(comp => ({ _attributes: { name: comp } }))
+      };
+    }
+
+    const calendar = await client.makeCalendar({
+      url: newCalendarUrl,
+      props: calendarProps
+    });
+
+    return formatSuccess('Calendar created successfully', {
+      displayName: validated.display_name,
+      url: newCalendarUrl,
+    });
+  },
+};

package/src/tools/calendar/update-calendar.js

@@ -0,0 +1,106 @@
+import { tsdavManager } from '../../tsdav-client.js';
+import { validateInput, updateCalendarSchema } from '../../validation.js';
+import { formatCalendarUpdateSuccess } from '../../formatters.js';
+
+/**
+ * Update an existing calendar's properties
+ */
+export const updateCalendar = {
+  name: 'update_calendar',
+  description: 'Update an existing calendar\'s properties (display name, description, color, timezone). Use this when user asks to "rename calendar", "change calendar color", or "update calendar properties"',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      calendar_url: {
+        type: 'string',
+        description: 'The URL of the calendar to update (get from list_calendars)',
+      },
+      display_name: {
+        type: 'string',
+        description: 'Optional: New display name for the calendar',
+      },
+      description: {
+        type: 'string',
+        description: 'Optional: New description for the calendar',
+      },
+      color: {
+        type: 'string',
+        description: 'Optional: New calendar color in hex format (e.g., #FF5733)',
+      },
+      timezone: {
+        type: 'string',
+        description: 'Optional: New timezone ID (e.g., Europe/Berlin)',
+      },
+    },
+    required: ['calendar_url'],
+  },
+  handler: async (args) => {
+    const validated = validateInput(updateCalendarSchema, args);
+    const client = tsdavManager.getCalDavClient();
+
+    // Build WebDAV PROPPATCH XML
+    let proppatchXml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+    proppatchXml += '<d:propertyupdate xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav" xmlns:x="http://apple.com/ns/ical/">\n';
+    proppatchXml += '  <d:set>\n';
+    proppatchXml += '    <d:prop>\n';
+
+    if (validated.display_name) {
+      proppatchXml += `      <d:displayname>${validated.display_name}</d:displayname>\n`;
+    }
+    if (validated.description) {
+      proppatchXml += `      <c:calendar-description>${validated.description}</c:calendar-description>\n`;
+    }
+    if (validated.color) {
+      proppatchXml += `      <x:calendar-color>${validated.color}</x:calendar-color>\n`;
+    }
+    if (validated.timezone) {
+      // Validate timezone format (basic check)
+      if (!validated.timezone.includes('/')) {
+        throw new Error(`Invalid timezone format: ${validated.timezone}. Expected format: "Europe/Berlin", "America/New_York", etc.`);
+      }
+      proppatchXml += `      <c:calendar-timezone>${validated.timezone}</c:calendar-timezone>\n`;
+    }
+
+    proppatchXml += '    </d:prop>\n';
+    proppatchXml += '  </d:set>\n';
+    proppatchXml += '</d:propertyupdate>';
+
+    // Use raw fetch with HTTP PROPPATCH method
+    const response = await fetch(validated.calendar_url, {
+      method: 'PROPPATCH',
+      headers: {
+        'Content-Type': 'text/xml; charset=utf-8',
+        ...client.authHeaders,
+      },
+      body: proppatchXml,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `PROPPATCH failed with status ${response.status} ${response.statusText}\n` +
+        `Response: ${errorText}\n\n` +
+        `This may indicate:\n` +
+        `- Invalid property value (check timezone format if specified)\n` +
+        `- Server does not support calendar property updates\n` +
+        `- Permission denied for this calendar`
+      );
+    }
+
+    // Fetch updated calendar to confirm
+    const calendars = await client.fetchCalendars();
+    const updatedCalendar = calendars.find(c => c.url === validated.calendar_url);
+
+    if (!updatedCalendar) {
+      throw new Error(`Calendar not found after update: ${validated.calendar_url}`);
+    }
+
+    // Return formatted success
+    return formatCalendarUpdateSuccess(updatedCalendar, {
+      display_name: validated.display_name,
+      description: validated.description,
+      color: validated.color,
+      timezone: validated.timezone,
+    });
+  },
+};

package/src/tools/calendar/update-event-fields.js

@@ -0,0 +1,119 @@
+import { tsdavManager } from '../../tsdav-client.js';
+import { validateInput } from '../../validation.js';
+import { formatSuccess, formatError } from '../../formatters.js';
+import { z } from 'zod';
+import { updateFields } from 'tsdav-utils';
+
+/**
+ * Schema for field-based event updates
+ * Supports all RFC 5545 iCalendar properties via tsdav-utils
+ * Common fields: SUMMARY, DESCRIPTION, LOCATION, DTSTART, DTEND, STATUS
+ * Custom properties: Any X-* property
+ */
+const updateEventFieldsSchema = z.object({
+  event_url: z.string().url('Event URL must be a valid URL'),
+  event_etag: z.string().min(1, 'Event etag is required'),
+  fields: z.record(z.string()).optional()
+});
+
+/**
+ * Field-agnostic event update tool powered by tsdav-utils
+ * Supports all RFC 5545 iCalendar properties without validation
+ *
+ * Features:
+ * - Any standard VEVENT property (SUMMARY, DESCRIPTION, LOCATION, DTSTART, etc.)
+ * - Custom X-* properties for extensions
+ * - Field-agnostic: no pre-defined field list required
+ */
+export const updateEventFields = {
+  name: 'update_event',
+  description: 'PREFERRED: Update event fields without iCal formatting. Supports: SUMMARY (title), DESCRIPTION (details), LOCATION (place), DTSTART (start time), DTEND (end time), STATUS (TENTATIVE/CONFIRMED/CANCELLED), and any RFC 5545 property including custom X-* properties (e.g., X-ZOOM-LINK, X-MEETING-ROOM).',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      event_url: {
+        type: 'string',
+        description: 'The URL of the event to update'
+      },
+      event_etag: {
+        type: 'string',
+        description: 'The etag of the event (required for conflict detection)'
+      },
+      fields: {
+        type: 'object',
+        description: 'Fields to update - use UPPERCASE property names (e.g., SUMMARY, LOCATION, DTSTART). Any RFC 5545 property or custom X-* property is supported.',
+        additionalProperties: {
+          type: 'string'
+        },
+        properties: {
+          SUMMARY: {
+            type: 'string',
+            description: 'Event title/summary'
+          },
+          DESCRIPTION: {
+            type: 'string',
+            description: 'Event description/details'
+          },
+          LOCATION: {
+            type: 'string',
+            description: 'Physical or virtual meeting location'
+          },
+          DTSTART: {
+            type: 'string',
+            description: 'Start datetime (ISO 8601 or iCal format: 20250128T100000Z)'
+          },
+          DTEND: {
+            type: 'string',
+            description: 'End datetime (ISO 8601 or iCal format)'
+          },
+          STATUS: {
+            type: 'string',
+            description: 'Event status: TENTATIVE, CONFIRMED, or CANCELLED'
+          }
+        }
+      }
+    },
+    required: ['event_url', 'event_etag']
+  },
+  handler: async (args) => {
+    try {
+      const validated = validateInput(updateEventFieldsSchema, args);
+      const client = tsdavManager.getCalDavClient();
+
+      // Step 1: Fetch the current event from server
+      const calendarUrl = validated.event_url.substring(0, validated.event_url.lastIndexOf('/') + 1);
+      const currentEvents = await client.fetchCalendarObjects({
+        calendar: { url: calendarUrl },
+        objectUrls: [validated.event_url]
+      });
+
+      if (!currentEvents || currentEvents.length === 0) {
+        throw new Error('Event not found');
+      }
+
+      const calendarObject = currentEvents[0];
+
+      // Step 2: Update fields using tsdav-utils (field-agnostic)
+      // Accepts any RFC 5545 property name (UPPERCASE)
+      const updatedData = updateFields(calendarObject, validated.fields || {});
+
+      // Step 3: Send the updated event back to server
+      const updateResponse = await client.updateCalendarObject({
+        calendarObject: {
+          url: validated.event_url,
+          data: updatedData,
+          etag: validated.event_etag
+        }
+      });
+
+      return formatSuccess('Event updated successfully', {
+        etag: updateResponse.etag,
+        updated_fields: Object.keys(validated.fields || {}),
+        message: `Updated ${Object.keys(validated.fields || {}).length} field(s): ${Object.keys(validated.fields || {}).join(', ')}`
+      });
+
+    } catch (error) {
+      return formatError('update_event_fields', error);
+    }
+  }
+};

package/src/tools/calendar/update-event-raw.js

@@ -0,0 +1,45 @@
+import { tsdavManager } from '../../tsdav-client.js';
+import { validateInput, updateEventSchema } from '../../validation.js';
+import { formatSuccess } from '../../formatters.js';
+
+/**
+ * Update an existing calendar event with raw iCal data
+ */
+export const updateEventRaw = {
+  name: 'update_event_raw',
+  description: 'ADVANCED: Update event with raw iCal data. Requires manual iCal formatting - use update_event instead for simple field updates (summary, description). Only use this if you have complete pre-formatted iCal data or need to update advanced iCal properties.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      event_url: {
+        type: 'string',
+        description: 'The URL of the event to update',
+      },
+      event_etag: {
+        type: 'string',
+        description: 'The etag of the event',
+      },
+      updated_ical_data: {
+        type: 'string',
+        description: 'The complete updated iCal data',
+      },
+    },
+    required: ['event_url', 'event_etag', 'updated_ical_data'],
+  },
+  handler: async (args) => {
+    const validated = validateInput(updateEventSchema, args);
+    const client = tsdavManager.getCalDavClient();
+
+    const response = await client.updateCalendarObject({
+      calendarObject: {
+        url: validated.event_url,
+        data: validated.updated_ical_data,
+        etag: validated.event_etag,
+      },
+    });
+
+    return formatSuccess('Event updated successfully', {
+      etag: response.etag,
+    });
+  },
+};

package/src/tools/contacts/addressbook-multi-get.js

@@ -0,0 +1,38 @@
+import { tsdavManager } from '../../tsdav-client.js';
+import { validateInput, addressBookMultiGetSchema } from '../../validation.js';
+import { formatContactList } from '../../formatters.js';
+
+/**
+ * Batch fetch multiple specific contacts by their URLs
+ */
+export const addressbookMultiGet = {
+  name: 'addressbook_multi_get',
+  description: 'Batch fetch multiple specific contacts by their URLs. Use when you have exact contact URLs and want to retrieve their details',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      addressbook_url: {
+        type: 'string',
+        description: 'The URL of the address book',
+      },
+      contact_urls: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Array of contact URLs to fetch',
+      },
+    },
+    required: ['addressbook_url', 'contact_urls'],
+  },
+  handler: async (args) => {
+    const validated = validateInput(addressBookMultiGetSchema, args);
+    const client = tsdavManager.getCardDavClient();
+
+    const vcards = await client.addressBookMultiGet({
+      url: validated.addressbook_url,
+      props: [{ name: 'getetag', namespace: 'DAV:' }, { name: 'address-data', namespace: 'urn:ietf:params:xml:ns:carddav' }],
+      objectUrls: validated.contact_urls,
+    });
+
+    return formatContactList(vcards, { url: validated.addressbook_url });
+  },
+};

package/src/tools/contacts/addressbook-query.js

@@ -0,0 +1,85 @@
+import { tsdavManager } from '../../tsdav-client.js';
+import { validateInput, addressBookQuerySchema } from '../../validation.js';
+import { formatContactList } from '../../formatters.js';
+
+/**
+ * Search and filter contacts efficiently
+ */
+export const addressbookQuery = {
+  name: 'addressbook_query',
+  description: '⭐ PREFERRED: Search and filter contacts efficiently (name, email, organization). Use for "find contacts with...", "search for email...", "contacts at company..." queries. Use instead of list_contacts when ANY filter is specified. Omit addressbook_url to search across ALL addressbooks automatically.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      addressbook_url: {
+        type: 'string',
+        description: 'Optional: Specific addressbook URL. Omit to search ALL addressbooks (recommended for "find contact X" queries). Only provide if user explicitly names an addressbook.',
+      },
+      name_filter: {
+        type: 'string',
+        description: 'Search contact names (full/given/family name). Example: "John Smith" or "Smith". At least one filter (name, email, or org) is required.',
+      },
+      email_filter: {
+        type: 'string',
+        description: 'Search contact email addresses. Use for queries like "Gmail contacts" → "@gmail.com", "work emails" → "@company.com", or specific addresses. At least one filter (name, email, or org) is required.',
+      },
+      organization_filter: {
+        type: 'string',
+        description: 'Search contact organizations/companies. Example: "Google" or "Acme Corp". At least one filter (name, email, or org) is required.',
+      },
+    },
+    required: [],
+  },
+  handler: async (args) => {
+    const validated = validateInput(addressBookQuerySchema, args);
+    const client = tsdavManager.getCardDavClient();
+    const addressBooks = await client.fetchAddressBooks();
+
+    // Resolve which addressbooks to search (all or specific)
+    const addressbooksToSearch = validated.addressbook_url
+      ? addressBooks.filter(ab => ab.url === validated.addressbook_url)
+      : addressBooks;
+
+    // Collect all vcards from all selected addressbooks
+    let allVCards = [];
+    for (const addressBook of addressbooksToSearch) {
+      const vcards = await client.fetchVCards({ addressBook });
+      // Add addressbook context for display
+      vcards.forEach(vcard => {
+        vcard._addressbookName = addressBook.displayName || addressBook.url;
+      });
+      allVCards = allVCards.concat(vcards);
+    }
+
+    let filteredContacts = allVCards;
+
+    if (validated.name_filter) {
+      const nameLower = validated.name_filter.toLowerCase();
+      filteredContacts = filteredContacts.filter(vcard => {
+        const fn = vcard.data?.match(/FN:(.+)/)?.[1] || '';
+        const n = vcard.data?.match(/N:(.+)/)?.[1] || '';
+        return fn.toLowerCase().includes(nameLower) || n.toLowerCase().includes(nameLower);
+      });
+    }
+
+    if (validated.email_filter) {
+      const emailLower = validated.email_filter.toLowerCase();
+      filteredContacts = filteredContacts.filter(vcard => {
+        const email = vcard.data?.match(/EMAIL[^:]*:(.+)/)?.[1] || '';
+        return email.toLowerCase().includes(emailLower);
+      });
+    }
+
+    if (validated.organization_filter) {
+      const orgLower = validated.organization_filter.toLowerCase();
+      filteredContacts = filteredContacts.filter(vcard => {
+        const org = vcard.data?.match(/ORG:(.+)/)?.[1] || '';
+        return org.toLowerCase().includes(orgLower);
+      });
+    }
+
+    // Format and return results (pass first addressbook for context, or null if multiple)
+    const singleAddressbook = addressbooksToSearch.length === 1 ? addressbooksToSearch[0] : null;
+    return formatContactList(filteredContacts, singleAddressbook);
+  },
+};

package/src/tools/contacts/create-contact.js

@@ -0,0 +1,84 @@
+import { tsdavManager } from '../../tsdav-client.js';
+import { validateInput, createContactSchema, sanitizeVCardString } from '../../validation.js';
+import { formatSuccess } from '../../formatters.js';
+import { findAddressbookOrThrow } from '../shared/helpers.js';
+
+/**
+ * Create a new contact (vCard)
+ */
+export const createContact = {
+  name: 'create_contact',
+  description: 'Create a new contact (vCard) with name, email, phone, organization, and other details',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      addressbook_url: {
+        type: 'string',
+        description: 'The URL of the address book to create the contact in',
+      },
+      full_name: {
+        type: 'string',
+        description: 'Full name of the contact',
+      },
+      family_name: {
+        type: 'string',
+        description: 'Family/last name',
+      },
+      given_name: {
+        type: 'string',
+        description: 'Given/first name',
+      },
+      email: {
+        type: 'string',
+        description: 'Email address (optional)',
+      },
+      phone: {
+        type: 'string',
+        description: 'Phone number (optional)',
+      },
+      organization: {
+        type: 'string',
+        description: 'Organization/company (optional)',
+      },
+      note: {
+        type: 'string',
+        description: 'Additional notes (optional)',
+      },
+    },
+    required: ['addressbook_url', 'full_name'],
+  },
+  handler: async (args) => {
+    const validated = validateInput(createContactSchema, args);
+    const client = tsdavManager.getCardDavClient();
+    const addressBooks = await client.fetchAddressBooks();
+    const addressBook = findAddressbookOrThrow(addressBooks, validated.addressbook_url);
+
+    const uid = `contact-${Date.now()}`;
+    const fullName = sanitizeVCardString(validated.full_name);
+    const familyName = validated.family_name ? sanitizeVCardString(validated.family_name) : '';
+    const givenName = validated.given_name ? sanitizeVCardString(validated.given_name) : '';
+    const email = validated.email ? sanitizeVCardString(validated.email) : '';
+    const phone = validated.phone ? sanitizeVCardString(validated.phone) : '';
+    const organization = validated.organization ? sanitizeVCardString(validated.organization) : '';
+    const note = validated.note ? sanitizeVCardString(validated.note) : '';
+
+    const vCardString = `BEGIN:VCARD
+VERSION:3.0
+UID:${uid}
+FN:${fullName}${familyName || givenName ? `\nN:${familyName};${givenName};;;` : ''}${email ? `\nEMAIL;TYPE=INTERNET:${email}` : ''}${phone ? `\nTEL;TYPE=CELL:${phone}` : ''}${organization ? `\nORG:${organization}` : ''}${note ? `\nNOTE:${note}` : ''}
+REV:${new Date().toISOString()}
+END:VCARD`;
+
+    const response = await client.createVCard({
+      addressBook,
+      filename: `${uid}.vcf`,
+      vCardString,
+    });
+
+    return formatSuccess('Contact created successfully', {
+      url: response.url,
+      etag: response.etag,
+      fullName: validated.full_name,
+    });
+  },
+};

package/src/tools/contacts/delete-contact.js

@@ -0,0 +1,38 @@
+import { tsdavManager } from '../../tsdav-client.js';
+import { validateInput, deleteContactSchema } from '../../validation.js';
+import { formatSuccess } from '../../formatters.js';
+
+/**
+ * Delete a contact (vCard) permanently
+ */
+export const deleteContact = {
+  name: 'delete_contact',
+  description: 'Delete a contact (vCard) permanently. Requires contact URL and etag',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      vcard_url: {
+        type: 'string',
+        description: 'The URL of the vCard to delete',
+      },
+      vcard_etag: {
+        type: 'string',
+        description: 'The etag of the vCard',
+      },
+    },
+    required: ['vcard_url', 'vcard_etag'],
+  },
+  handler: async (args) => {
+    const validated = validateInput(deleteContactSchema, args);
+    const client = tsdavManager.getCardDavClient();
+
+    await client.deleteVCard({
+      vCard: {
+        url: validated.vcard_url,
+        etag: validated.vcard_etag,
+      },
+    });
+
+    return formatSuccess('Contact deleted successfully');
+  },
+};

package/src/tools/contacts/index.js

@@ -0,0 +1,13 @@
+/**
+ * Contact Tools - CardDAV operations
+ * Exports all contact-related tools
+ */
+
+export { listAddressbooks } from './list-addressbooks.js';
+export { listContacts } from './list-contacts.js';
+export { createContact } from './create-contact.js';
+export { updateContactFields } from './update-contact-fields.js';
+export { updateContactRaw } from './update-contact-raw.js';
+export { deleteContact } from './delete-contact.js';
+export { addressbookQuery } from './addressbook-query.js';
+export { addressbookMultiGet } from './addressbook-multi-get.js';