@marktoflow/integrations 2.0.1 → 2.0.3

package/dist/services/gmail.d.ts

@@ -0,0 +1,116 @@
+import { gmail_v1 } from 'googleapis';
+import { SDKInitializer } from '@marktoflow/core';
+export interface GmailEmail {
+    id: string;
+    threadId: string;
+    subject: string;
+    from: string;
+    to: string[];
+    cc?: string[];
+    bcc?: string[];
+    date: string;
+    snippet: string;
+    body?: string;
+    bodyHtml?: string;
+    labels: string[];
+    isUnread: boolean;
+    hasAttachments: boolean;
+}
+export interface GetEmailsOptions {
+    query?: string;
+    maxResults?: number;
+    labelIds?: string[];
+    includeSpamTrash?: boolean;
+    pageToken?: string;
+}
+export interface SendEmailOptions {
+    to: string | string[];
+    subject: string;
+    body: string;
+    bodyHtml?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+    replyTo?: string;
+    inReplyTo?: string;
+    references?: string;
+}
+export interface CreateDraftOptions {
+    to: string | string[];
+    subject: string;
+    body: string;
+    bodyHtml?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+    replyTo?: string;
+    threadId?: string;
+}
+export interface GmailDraft {
+    id: string;
+    messageId: string;
+    threadId?: string;
+}
+export interface GetEmailsResult {
+    emails: GmailEmail[];
+    nextPageToken?: string;
+    resultSizeEstimate: number;
+}
+/**
+ * Gmail actions for workflow integration
+ */
+export declare class GmailActions {
+    private gmail;
+    constructor(gmail: gmail_v1.Gmail);
+    /**
+     * Get emails from Gmail with optional filtering
+     */
+    getEmails(options?: GetEmailsOptions): Promise<GetEmailsResult>;
+    /**
+     * Send an email via Gmail
+     */
+    sendEmail(options: SendEmailOptions): Promise<{
+        id: string;
+        threadId: string;
+    }>;
+    /**
+     * Create a draft email in Gmail
+     */
+    createDraft(options: CreateDraftOptions): Promise<GmailDraft>;
+    /**
+     * Get a specific email by ID
+     */
+    getEmail(id: string): Promise<GmailEmail>;
+    /**
+     * Mark an email as read
+     */
+    markAsRead(id: string): Promise<void>;
+    /**
+     * Mark an email as unread
+     */
+    markAsUnread(id: string): Promise<void>;
+    /**
+     * Add labels to an email
+     */
+    addLabels(id: string, labelIds: string[]): Promise<void>;
+    /**
+     * Remove labels from an email
+     */
+    removeLabels(id: string, labelIds: string[]): Promise<void>;
+    /**
+     * Trash an email
+     */
+    trash(id: string): Promise<void>;
+    /**
+     * Delete an email permanently
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Get list of labels
+     */
+    listLabels(): Promise<{
+        id: string;
+        name: string;
+        type: string;
+    }[]>;
+}
+export declare const GmailInitializer: SDKInitializer;
+//# sourceMappingURL=gmail.d.ts.map

package/dist/services/google-calendar.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Google Calendar Integration
+ *
+ * Calendar and event management.
+ * API Docs: https://developers.google.com/calendar/api
+ */
+import { calendar_v3 } from 'googleapis';
+import { SDKInitializer } from '@marktoflow/core';
+export interface CalendarEvent {
+    id: string;
+    summary: string;
+    description?: string;
+    location?: string;
+    start: {
+        dateTime?: string;
+        date?: string;
+        timeZone?: string;
+    };
+    end: {
+        dateTime?: string;
+        date?: string;
+        timeZone?: string;
+    };
+    attendees?: {
+        email: string;
+        displayName?: string;
+        responseStatus?: string;
+    }[];
+    creator?: {
+        email: string;
+        displayName?: string;
+    };
+    organizer?: {
+        email: string;
+        displayName?: string;
+    };
+    status?: string;
+    htmlLink?: string;
+    recurringEventId?: string;
+    recurrence?: string[];
+    reminders?: {
+        useDefault: boolean;
+        overrides?: {
+            method: string;
+            minutes: number;
+        }[];
+    };
+    conferenceData?: {
+        conferenceId?: string;
+        conferenceSolution?: {
+            name: string;
+            iconUri?: string;
+        };
+        entryPoints?: {
+            entryPointType: string;
+            uri: string;
+            label?: string;
+        }[];
+    };
+}
+export interface CalendarInfo {
+    id: string;
+    summary: string;
+    description?: string;
+    location?: string;
+    timeZone?: string;
+    accessRole?: string;
+    primary?: boolean;
+}
+export interface CreateEventOptions {
+    summary: string;
+    description?: string;
+    location?: string;
+    start: {
+        dateTime?: string;
+        date?: string;
+        timeZone?: string;
+    };
+    end: {
+        dateTime?: string;
+        date?: string;
+        timeZone?: string;
+    };
+    attendees?: string[] | {
+        email: string;
+        displayName?: string;
+    }[];
+    recurrence?: string[];
+    reminders?: {
+        useDefault?: boolean;
+        overrides?: {
+            method: 'email' | 'popup';
+            minutes: number;
+        }[];
+    };
+    conferenceData?: {
+        createRequest?: {
+            requestId: string;
+            conferenceSolutionKey?: {
+                type: string;
+            };
+        };
+    };
+    sendUpdates?: 'all' | 'externalOnly' | 'none';
+}
+export interface UpdateEventOptions extends Partial<CreateEventOptions> {
+    sendUpdates?: 'all' | 'externalOnly' | 'none';
+}
+export interface ListEventsOptions {
+    timeMin?: string;
+    timeMax?: string;
+    maxResults?: number;
+    orderBy?: 'startTime' | 'updated';
+    q?: string;
+    singleEvents?: boolean;
+    showDeleted?: boolean;
+    pageToken?: string;
+}
+export interface FreeBusyQuery {
+    timeMin: string;
+    timeMax: string;
+    items: {
+        id: string;
+    }[];
+    timeZone?: string;
+}
+export interface FreeBusyResponse {
+    calendars: {
+        [calendarId: string]: {
+            busy: {
+                start: string;
+                end: string;
+            }[];
+            errors?: unknown[];
+        };
+    };
+}
+/**
+ * Google Calendar actions for workflow integration
+ */
+export declare class GoogleCalendarActions {
+    private calendar;
+    constructor(calendar: calendar_v3.Calendar);
+    /**
+     * List user's calendars
+     */
+    listCalendars(): Promise<CalendarInfo[]>;
+    /**
+     * Get a specific calendar
+     */
+    getCalendar(calendarId?: string): Promise<CalendarInfo>;
+    /**
+     * List events from a calendar
+     */
+    listEvents(calendarId?: string, options?: ListEventsOptions): Promise<{
+        events: CalendarEvent[];
+        nextPageToken?: string;
+    }>;
+    /**
+     * Get a specific event
+     */
+    getEvent(calendarId: string, eventId: string): Promise<CalendarEvent>;
+    /**
+     * Create a new event
+     */
+    createEvent(calendarId: string | undefined, options: CreateEventOptions): Promise<CalendarEvent>;
+    /**
+     * Update an existing event
+     */
+    updateEvent(calendarId: string, eventId: string, options: UpdateEventOptions): Promise<CalendarEvent>;
+    /**
+     * Delete an event
+     */
+    deleteEvent(calendarId: string, eventId: string, sendUpdates?: 'all' | 'externalOnly' | 'none'): Promise<void>;
+    /**
+     * Quick add event using natural language
+     */
+    quickAddEvent(calendarId: string | undefined, text: string): Promise<CalendarEvent>;
+    /**
+     * Move event to another calendar
+     */
+    moveEvent(sourceCalendarId: string, eventId: string, destinationCalendarId: string): Promise<CalendarEvent>;
+    /**
+     * Query free/busy information
+     */
+    queryFreeBusy(query: FreeBusyQuery): Promise<FreeBusyResponse>;
+    /**
+     * Create a calendar
+     */
+    createCalendar(summary: string, options?: {
+        description?: string;
+        location?: string;
+        timeZone?: string;
+    }): Promise<CalendarInfo>;
+    /**
+     * Delete a calendar
+     */
+    deleteCalendar(calendarId: string): Promise<void>;
+    /**
+     * Watch for changes to a calendar
+     */
+    watchEvents(calendarId: string, webhookUrl: string, options?: {
+        token?: string;
+        expiration?: number;
+    }): Promise<{
+        id: string;
+        resourceId: string;
+        expiration: string;
+    }>;
+    /**
+     * Stop watching for changes
+     */
+    stopWatching(channelId: string, resourceId: string): Promise<void>;
+    /**
+     * Parse calendar event from API response
+     */
+    private parseEvent;
+}
+export declare const GoogleCalendarInitializer: SDKInitializer;
+//# sourceMappingURL=google-calendar.d.ts.map

package/dist/services/google-docs.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Google Docs Integration
+ *
+ * Document creation and editing platform.
+ * API Docs: https://developers.google.com/docs/api
+ */
+import { docs_v1 } from 'googleapis';
+import { SDKInitializer } from '@marktoflow/core';
+export interface Document {
+    documentId: string;
+    title: string;
+    body?: DocumentBody;
+    revisionId?: string;
+    suggestionsViewMode?: string;
+}
+export interface DocumentBody {
+    content: StructuralElement[];
+}
+export interface StructuralElement {
+    startIndex?: number;
+    endIndex?: number;
+    paragraph?: Paragraph;
+    table?: Table;
+    sectionBreak?: unknown;
+}
+export interface Paragraph {
+    elements: ParagraphElement[];
+    paragraphStyle?: ParagraphStyle;
+}
+export interface ParagraphElement {
+    startIndex?: number;
+    endIndex?: number;
+    textRun?: TextRun;
+}
+export interface TextRun {
+    content: string;
+    textStyle?: TextStyle;
+}
+export interface TextStyle {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    fontSize?: {
+        magnitude: number;
+        unit: string;
+    };
+    foregroundColor?: Color;
+    backgroundColor?: Color;
+    link?: {
+        url: string;
+    };
+}
+export interface ParagraphStyle {
+    headingId?: string;
+    namedStyleType?: string;
+    alignment?: string;
+    lineSpacing?: number;
+    direction?: string;
+    spacingMode?: string;
+    spaceAbove?: {
+        magnitude: number;
+        unit: string;
+    };
+    spaceBelow?: {
+        magnitude: number;
+        unit: string;
+    };
+    indentFirstLine?: {
+        magnitude: number;
+        unit: string;
+    };
+    indentStart?: {
+        magnitude: number;
+        unit: string;
+    };
+    indentEnd?: {
+        magnitude: number;
+        unit: string;
+    };
+}
+export interface Color {
+    rgbColor?: {
+        red: number;
+        green: number;
+        blue: number;
+    };
+}
+export interface Table {
+    rows: number;
+    columns: number;
+    tableRows: TableRow[];
+}
+export interface TableRow {
+    tableCells: TableCell[];
+}
+export interface TableCell {
+    content: StructuralElement[];
+}
+export interface CreateDocumentOptions {
+    title: string;
+}
+export interface InsertTextOptions {
+    text: string;
+    index?: number;
+}
+export interface DeleteContentOptions {
+    startIndex: number;
+    endIndex: number;
+}
+export interface FormatTextOptions {
+    startIndex: number;
+    endIndex: number;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    fontSize?: number;
+    foregroundColor?: {
+        red: number;
+        green: number;
+        blue: number;
+    };
+}
+export interface InsertTableOptions {
+    rows: number;
+    columns: number;
+    index?: number;
+}
+/**
+ * Google Docs actions for workflow integration
+ */
+export declare class GoogleDocsActions {
+    private docs;
+    constructor(docs: docs_v1.Docs);
+    /**
+     * Get a document by ID
+     */
+    getDocument(documentId: string): Promise<Document>;
+    /**
+     * Create a new document
+     */
+    createDocument(options: CreateDocumentOptions): Promise<Document>;
+    /**
+     * Get document text content
+     */
+    getDocumentText(documentId: string): Promise<string>;
+    /**
+     * Insert text into a document
+     */
+    insertText(documentId: string, options: InsertTextOptions): Promise<void>;
+    /**
+     * Append text to the end of a document
+     */
+    appendText(documentId: string, text: string): Promise<void>;
+    /**
+     * Delete content from a document
+     */
+    deleteContent(documentId: string, options: DeleteContentOptions): Promise<void>;
+    /**
+     * Replace all occurrences of text
+     */
+    replaceAllText(documentId: string, find: string, replace: string, matchCase?: boolean): Promise<number>;
+    /**
+     * Format text
+     */
+    formatText(documentId: string, options: FormatTextOptions): Promise<void>;
+    /**
+     * Insert a table
+     */
+    insertTable(documentId: string, options: InsertTableOptions): Promise<void>;
+    /**
+     * Insert a page break
+     */
+    insertPageBreak(documentId: string, index?: number): Promise<void>;
+    /**
+     * Create a named range
+     */
+    createNamedRange(documentId: string, name: string, startIndex: number, endIndex: number): Promise<string>;
+    /**
+     * Update paragraph style
+     */
+    updateParagraphStyle(documentId: string, startIndex: number, endIndex: number, style: {
+        headingId?: string;
+        namedStyleType?: string;
+        alignment?: 'ALIGNMENT_UNSPECIFIED' | 'START' | 'CENTER' | 'END' | 'JUSTIFIED';
+    }): Promise<void>;
+    /**
+     * Insert inline image
+     */
+    insertImage(documentId: string, imageUri: string, index?: number): Promise<void>;
+    /**
+     * Batch update operations
+     */
+    batchUpdate(documentId: string, requests: docs_v1.Schema$Request[]): Promise<docs_v1.Schema$BatchUpdateDocumentResponse>;
+}
+export declare const GoogleDocsInitializer: SDKInitializer;
+//# sourceMappingURL=google-docs.d.ts.map

package/dist/services/google-drive.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Google Drive Integration
+ *
+ * File storage and collaboration platform.
+ * API Docs: https://developers.google.com/drive/api
+ */
+import { drive_v3 } from 'googleapis';
+import { SDKInitializer } from '@marktoflow/core';
+import { Readable } from 'stream';
+export interface DriveFile {
+    id: string;
+    name: string;
+    mimeType: string;
+    parents?: string[];
+    size?: string;
+    createdTime?: string;
+    modifiedTime?: string;
+    webViewLink?: string;
+    webContentLink?: string;
+    description?: string;
+    starred?: boolean;
+    trashed?: boolean;
+    shared?: boolean;
+    owners?: {
+        displayName?: string;
+        emailAddress?: string;
+    }[];
+    permissions?: DrivePermission[];
+}
+export interface DrivePermission {
+    id: string;
+    type: 'user' | 'group' | 'domain' | 'anyone';
+    role: 'owner' | 'organizer' | 'fileOrganizer' | 'writer' | 'commenter' | 'reader';
+    emailAddress?: string;
+    displayName?: string;
+    deleted?: boolean;
+}
+export interface ListFilesOptions {
+    q?: string;
+    pageSize?: number;
+    pageToken?: string;
+    orderBy?: string;
+    spaces?: string;
+    fields?: string;
+    includeItemsFromAllDrives?: boolean;
+    supportsAllDrives?: boolean;
+}
+export interface CreateFileOptions {
+    name: string;
+    mimeType?: string;
+    parents?: string[];
+    description?: string;
+    content?: string | Buffer | Readable;
+    contentType?: string;
+}
+export interface UpdateFileOptions {
+    name?: string;
+    description?: string;
+    starred?: boolean;
+    trashed?: boolean;
+    parents?: string[];
+    content?: string | Buffer | Readable;
+    contentType?: string;
+}
+export interface ShareFileOptions {
+    type: 'user' | 'group' | 'domain' | 'anyone';
+    role: 'owner' | 'organizer' | 'fileOrganizer' | 'writer' | 'commenter' | 'reader';
+    emailAddress?: string;
+    domain?: string;
+    allowFileDiscovery?: boolean;
+    sendNotificationEmail?: boolean;
+    emailMessage?: string;
+}
+/**
+ * Google Drive actions for workflow integration
+ */
+export declare class GoogleDriveActions {
+    private drive;
+    constructor(drive: drive_v3.Drive);
+    /**
+     * List files and folders
+     */
+    listFiles(options?: ListFilesOptions): Promise<{
+        files: DriveFile[];
+        nextPageToken?: string;
+    }>;
+    /**
+     * Get a file by ID
+     */
+    getFile(fileId: string, fields?: string): Promise<DriveFile>;
+    /**
+     * Download file content
+     */
+    downloadFile(fileId: string): Promise<Buffer>;
+    /**
+     * Export Google Workspace file to another format
+     */
+    exportFile(fileId: string, mimeType: string): Promise<Buffer>;
+    /**
+     * Create a file or folder
+     */
+    createFile(options: CreateFileOptions): Promise<DriveFile>;
+    /**
+     * Create a folder
+     */
+    createFolder(name: string, parentId?: string): Promise<DriveFile>;
+    /**
+     * Update a file
+     */
+    updateFile(fileId: string, options: UpdateFileOptions): Promise<DriveFile>;
+    /**
+     * Delete a file
+     */
+    deleteFile(fileId: string): Promise<void>;
+    /**
+     * Copy a file
+     */
+    copyFile(fileId: string, name: string, parents?: string[]): Promise<DriveFile>;
+    /**
+     * Move a file
+     */
+    moveFile(fileId: string, newParentId: string): Promise<DriveFile>;
+    /**
+     * Share a file
+     */
+    shareFile(fileId: string, options: ShareFileOptions): Promise<DrivePermission>;
+    /**
+     * List permissions for a file
+     */
+    listPermissions(fileId: string): Promise<DrivePermission[]>;
+    /**
+     * Remove a permission
+     */
+    removePermission(fileId: string, permissionId: string): Promise<void>;
+    /**
+     * Search files
+     */
+    searchFiles(query: string, options?: Omit<ListFilesOptions, 'q'>): Promise<DriveFile[]>;
+    /**
+     * Get files in a folder
+     */
+    getFilesInFolder(folderId: string): Promise<DriveFile[]>;
+    /**
+     * Parse file from API response
+     */
+    private parseFile;
+}
+export declare const GoogleDriveInitializer: SDKInitializer;
+//# sourceMappingURL=google-drive.d.ts.map