@mcp-z/mcp-gmail 1.0.0

package/dist/cjs/email/querying/search-execution.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "searchMessages", {
+    enumerable: true,
+    get: function() {
+        return searchMessages;
+    }
+});
+var _pagination = require("./pagination.js");
+var _querybuilder = require("./query-builder.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function buildGmailQ(query) {
+    var _ref;
+    if (!query) return '';
+    var emitted = (0, _querybuilder.toGmailQuery)(query);
+    return (_ref = emitted === null || emitted === void 0 ? void 0 : emitted.q) !== null && _ref !== void 0 ? _ref : '';
+}
+function searchMessages(gmail, opts) {
+    return _async_to_generator(function() {
+        var query, _opts_pageSize, pageSize, _opts_includeBody, includeBody, pageToken, logger, gmailQ, metadataHeaders, pageParams, result;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    query = opts.query, _opts_pageSize = opts.pageSize, pageSize = _opts_pageSize === void 0 ? 50 : _opts_pageSize, _opts_includeBody = opts.includeBody, includeBody = _opts_includeBody === void 0 ? false : _opts_includeBody, pageToken = opts.pageToken, logger = opts.logger;
+                    gmailQ = buildGmailQ(query);
+                    metadataHeaders = [
+                        'Date',
+                        'Subject',
+                        'From',
+                        'To',
+                        'Cc',
+                        'Bcc'
+                    ];
+                    // Always fetch metadata headers - body is additional content, not a replacement for headers
+                    pageParams = {
+                        gmailQ: gmailQ,
+                        pageSize: pageSize,
+                        body: includeBody,
+                        metadataHeaders: metadataHeaders,
+                        pageToken: pageToken,
+                        logger: logger
+                    };
+                    return [
+                        4,
+                        (0, _pagination.fetchMessagesPage)(gmail, pageParams)
+                    ];
+                case 1:
+                    result = _state.sent();
+                    // Return raw Gmail messages - transformation happens in caller
+                    return [
+                        2,
+                        {
+                            messages: result.messages,
+                            nextPageToken: result.nextPageToken
+                        }
+                    ];
+            }
+        });
+    })();
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/email/querying/search-execution.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-gmail/src/email/querying/search-execution.ts"],"sourcesContent":["import type { gmail_v1 } from 'googleapis';\nimport type { GmailQuery as QueryNode } from '../../schemas/gmail-query-schema.js';\nimport type { Logger } from '../../types.js';\nimport { type FetchMessagesPageParams, fetchMessagesPage } from './pagination.js';\nimport { toGmailQuery } from './query-builder.js';\n\nexport interface GmailSearchOptions {\n  readonly query?: QueryNode;\n  readonly pageSize?: number;\n  readonly includeBody?: boolean;\n  readonly pageToken: string | undefined; // For pagination support - explicit undefined allowed\n  readonly logger: Logger;\n}\n\nexport interface GmailEmailSummary {\n  readonly id: string;\n  readonly provider: 'gmail';\n  readonly threadId?: string;\n  readonly date?: string;\n  readonly from?: string;\n  readonly fromName?: string;\n  readonly to?: string;\n  readonly cc?: string;\n  readonly bcc?: string;\n  readonly subject?: string;\n  readonly snippet?: string;\n  readonly body?: string;\n}\n\nfunction buildGmailQ(query: QueryNode | undefined): string {\n  if (!query) return '';\n  const emitted = toGmailQuery(query);\n  return emitted?.q ?? '';\n}\n\nexport interface GmailSearchResult {\n  readonly messages: gmail_v1.Schema$Message[]; // Raw Gmail API messages for transformation by caller\n  readonly nextPageToken: string | undefined;\n}\n\nexport async function searchMessages(gmail: gmail_v1.Gmail, opts: GmailSearchOptions): Promise<GmailSearchResult> {\n  const { query, pageSize = 50, includeBody = false, pageToken, logger } = opts;\n  const gmailQ = buildGmailQ(query);\n  const metadataHeaders = ['Date', 'Subject', 'From', 'To', 'Cc', 'Bcc'];\n  // Always fetch metadata headers - body is additional content, not a replacement for headers\n  const pageParams: FetchMessagesPageParams = {\n    gmailQ,\n    pageSize,\n    body: includeBody,\n    metadataHeaders,\n    pageToken,\n    logger,\n  };\n  const result = await fetchMessagesPage(gmail, pageParams);\n\n  // Return raw Gmail messages - transformation happens in caller\n  return {\n    messages: result.messages,\n    nextPageToken: result.nextPageToken,\n  };\n}\n"],"names":["searchMessages","buildGmailQ","query","emitted","toGmailQuery","q","gmail","opts","pageSize","includeBody","pageToken","logger","gmailQ","metadataHeaders","pageParams","result","body","fetchMessagesPage","messages","nextPageToken"],"mappings":";;;;+BAwCsBA;;;eAAAA;;;0BArC0C;4BACnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyB7B,SAASC,YAAYC,KAA4B;;IAC/C,IAAI,CAACA,OAAO,OAAO;IACnB,IAAMC,UAAUC,IAAAA,0BAAY,EAACF;IAC7B,eAAOC,oBAAAA,8BAAAA,QAASE,CAAC,uCAAI;AACvB;AAOO,SAAeL,eAAeM,KAAqB,EAAEC,IAAwB;;YAC1EL,uBAAOM,6BAAeC,aAAqBC,WAAWC,QACxDC,QACAC,iBAEAC,YAQAC;;;;oBAZEb,QAAiEK,KAAjEL,wBAAiEK,KAA1DC,UAAAA,uCAAW,yCAA+CD,KAA3CE,aAAAA,6CAAc,2BAAOC,YAAsBH,KAAtBG,WAAWC,SAAWJ,KAAXI;oBACxDC,SAASX,YAAYC;oBACrBW;wBAAmB;wBAAQ;wBAAW;wBAAQ;wBAAM;wBAAM;;oBAChE,4FAA4F;oBACtFC,aAAsC;wBAC1CF,QAAAA;wBACAJ,UAAAA;wBACAQ,MAAMP;wBACNI,iBAAAA;wBACAH,WAAAA;wBACAC,QAAAA;oBACF;oBACe;;wBAAMM,IAAAA,6BAAiB,EAACX,OAAOQ;;;oBAAxCC,SAAS;oBAEf,+DAA+D;oBAC/D;;wBAAO;4BACLG,UAAUH,OAAOG,QAAQ;4BACzBC,eAAeJ,OAAOI,aAAa;wBACrC;;;;IACF"}

package/dist/cjs/index.d.cts

@@ -0,0 +1,8 @@
+import type { ServerConfig } from './types.js';
+export { GOOGLE_SCOPE } from './constants.js';
+export * as mcp from './mcp/index.js';
+export * as schemas from './schemas/index.js';
+export * as setup from './setup/index.js';
+export * from './types.js';
+export declare function startServer(config: ServerConfig): Promise<void>;
+export default function main(): Promise<void>;

package/dist/cjs/index.d.ts

@@ -0,0 +1,8 @@
+import type { ServerConfig } from './types.js';
+export { GOOGLE_SCOPE } from './constants.js';
+export * as mcp from './mcp/index.js';
+export * as schemas from './schemas/index.js';
+export * as setup from './setup/index.js';
+export * from './types.js';
+export declare function startServer(config: ServerConfig): Promise<void>;
+export default function main(): Promise<void>;

package/dist/cjs/index.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get GOOGLE_SCOPE () {
+        return _constantsts.GOOGLE_SCOPE;
+    },
+    get default () {
+        return main;
+    },
+    get mcp () {
+        return _index;
+    },
+    get schemas () {
+        return _index1;
+    },
+    get setup () {
+        return _index2;
+    },
+    get startServer () {
+        return startServer;
+    }
+});
+var _config = require("./setup/config.js");
+var _http = require("./setup/http.js");
+var _stdio = require("./setup/stdio.js");
+var _constantsts = require("./constants.js");
+var _index = /*#__PURE__*/ _interop_require_wildcard(require("./mcp/index.js"));
+var _index1 = /*#__PURE__*/ _interop_require_wildcard(require("./schemas/index.js"));
+var _index2 = /*#__PURE__*/ _interop_require_wildcard(require("./setup/index.js"));
+_export_star(require("./types.js"), exports);
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function startServer(config) {
+    return _async_to_generator(function() {
+        var _ref, logger, close, _tmp;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!(config.transport.type === 'stdio')) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        (0, _stdio.createStdioServer)(config)
+                    ];
+                case 1:
+                    _tmp = _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 2:
+                    return [
+                        4,
+                        (0, _http.createHTTPServer)(config)
+                    ];
+                case 3:
+                    _tmp = _state.sent();
+                    _state.label = 4;
+                case 4:
+                    _ref = _tmp, logger = _ref.logger, close = _ref.close;
+                    process.on('SIGINT', function() {
+                        return _async_to_generator(function() {
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        return [
+                                            4,
+                                            close()
+                                        ];
+                                    case 1:
+                                        _state.sent();
+                                        process.exit(0);
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        })();
+                    });
+                    logger.info("Server started with ".concat(config.transport.type, " transport"));
+                    return [
+                        4,
+                        new Promise(function() {})
+                    ];
+                case 5:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function main() {
+    return _async_to_generator(function() {
+        var versionHelpResult, config;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    // Check for help/version flags FIRST, before config parsing
+                    versionHelpResult = (0, _config.handleVersionHelp)(process.argv);
+                    if (versionHelpResult.handled) {
+                        console.log(versionHelpResult.output);
+                        process.exit(0);
+                    }
+                    // Only parse config if no help/version flags
+                    config = (0, _config.createConfig)();
+                    return [
+                        4,
+                        startServer(config)
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+if (process.argv[1] === new URL(require("url").pathToFileURL(__filename).toString()).pathname) {
+    main();
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-gmail/src/index.ts"],"sourcesContent":["import { createConfig, handleVersionHelp } from './setup/config.js';\nimport { createHTTPServer } from './setup/http.js';\nimport { createStdioServer } from './setup/stdio.js';\nimport type { ServerConfig } from './types.js';\n\nexport { GOOGLE_SCOPE } from './constants.ts';\nexport * as mcp from './mcp/index.js';\nexport * as schemas from './schemas/index.js';\nexport * as setup from './setup/index.js';\nexport * from './types.js';\n\nexport async function startServer(config: ServerConfig): Promise<void> {\n  const { logger, close } = config.transport.type === 'stdio' ? await createStdioServer(config) : await createHTTPServer(config);\n\n  process.on('SIGINT', async () => {\n    await close();\n    process.exit(0);\n  });\n\n  logger.info(`Server started with ${config.transport.type} transport`);\n  await new Promise(() => {});\n}\n\nexport default async function main(): Promise<void> {\n  // Check for help/version flags FIRST, before config parsing\n  const versionHelpResult = handleVersionHelp(process.argv);\n  if (versionHelpResult.handled) {\n    console.log(versionHelpResult.output);\n    process.exit(0);\n  }\n\n  // Only parse config if no help/version flags\n  const config = createConfig();\n  await startServer(config);\n}\n\nif (process.argv[1] === new URL(import.meta.url).pathname) {\n  main();\n}\n"],"names":["GOOGLE_SCOPE","main","mcp","schemas","setup","startServer","config","logger","close","transport","type","createStdioServer","createHTTPServer","process","on","exit","info","Promise","versionHelpResult","handleVersionHelp","argv","handled","console","log","output","createConfig","URL","pathname"],"mappings":";;;;;;;;;;;QAKSA;eAAAA,yBAAY;;QAkBrB;eAA8BC;;QAjBlBC;;;QACAC;;;QACAC;;;QAGUC;eAAAA;;;sBAX0B;oBACf;qBACC;2BAGL;6DACR;8DACI;8DACF;qBACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEP,SAAeA,YAAYC,MAAoB;;YAC1BA,MAAlBC,QAAQC;;;;yBAAUF,CAAAA,OAAOG,SAAS,CAACC,IAAI,KAAK,OAAM,GAAhCJ;;;;oBAAoC;;wBAAMK,IAAAA,wBAAiB,EAACL;;;2BAAxB;;;;;;oBAAkC;;wBAAMM,IAAAA,sBAAgB,EAACN;;;2BAAvB;;;oBAAtEA,aAAlBC,SAAkBD,KAAlBC,QAAQC,QAAUF,KAAVE;oBAEhBK,QAAQC,EAAE,CAAC,UAAU;;;;;wCACnB;;4CAAMN;;;wCAAN;wCACAK,QAAQE,IAAI,CAAC;;;;;;wBACf;;oBAEAR,OAAOS,IAAI,CAAC,AAAC,uBAA4C,OAAtBV,OAAOG,SAAS,CAACC,IAAI,EAAC;oBACzD;;wBAAM,IAAIO,QAAQ,YAAO;;;oBAAzB;;;;;;IACF;;AAEe,SAAehB;;YAEtBiB,mBAOAZ;;;;oBARN,4DAA4D;oBACtDY,oBAAoBC,IAAAA,yBAAiB,EAACN,QAAQO,IAAI;oBACxD,IAAIF,kBAAkBG,OAAO,EAAE;wBAC7BC,QAAQC,GAAG,CAACL,kBAAkBM,MAAM;wBACpCX,QAAQE,IAAI,CAAC;oBACf;oBAEA,6CAA6C;oBACvCT,SAASmB,IAAAA,oBAAY;oBAC3B;;wBAAMpB,YAAYC;;;oBAAlB;;;;;;IACF;;AAEA,IAAIO,QAAQO,IAAI,CAAC,EAAE,KAAK,IAAIM,IAAI,qDAAiBC,QAAQ,EAAE;IACzD1B;AACF"}

package/dist/cjs/labels/gmail-labels.d.cts

@@ -0,0 +1,2 @@
+import type { gmail_v1 } from 'googleapis';
+export declare function ensureLabelId(gmail: gmail_v1.Gmail, userId: string, labelName: string): Promise<string>;

package/dist/cjs/labels/gmail-labels.d.ts

@@ -0,0 +1,2 @@
+import type { gmail_v1 } from 'googleapis';
+export declare function ensureLabelId(gmail: gmail_v1.Gmail, userId: string, labelName: string): Promise<string>;