@teleporthq/teleport-plugin-next-workflows 0.43.67 → 0.43.69

package/dist/cjs/types.d.ts

@@ -6,6 +6,12 @@ export interface WorkflowSegment {
     nodeIds: string[];
     nodes: UIDLWorkflowNode[];
     edges: UIDLWorkflowEdge[];
+    /**
+     * The nodes a branch decided outside this segment can start at: those with a
+     * predecessor outside it, or with none. Only there may a client's skip mark
+     * take effect (see `claimSegmentContext` in the runtime).
+     */
+    entryNodeIds?: string[];
 }
 export interface SecretEntry {
     envVarName: string;

package/dist/cjs/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAE/E,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAEtD,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAA;IACV,GAAG,EAAE,oBAAoB,CAAA;IACzB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,KAAK,EAAE,gBAAgB,EAAE,CAAA;IACzB,KAAK,EAAE,gBAAgB,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,OAAO,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAE/E,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAEtD,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAA;IACV,GAAG,EAAE,oBAAoB,CAAA;IACzB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,KAAK,EAAE,gBAAgB,EAAE,CAAA;IACzB,KAAK,EAAE,gBAAgB,EAAE,CAAA;IACzB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,OAAO,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAA"}

package/dist/cjs/webhook-delivery-lease/index.d.ts

@@ -0,0 +1,8 @@
+import { ProjectPluginStructure } from '@teleporthq/teleport-types';
+/**
+ * Writes `utils/workflows/webhook-delivery-lease.js` into the project, once —
+ * called for every payment webhook route, which requires it. Postgres only:
+ * on another data source the module claims nothing, with the same export.
+ */
+export declare const ensureWebhookDeliveryLeaseModule: (structure: ProjectPluginStructure) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/webhook-delivery-lease/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/webhook-delivery-lease/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,sBAAsB,EAAE,MAAM,4BAA4B,CAAA;AAU7E;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,cAAe,sBAAsB,KAAG,IA4BpF,CAAA"}

package/dist/cjs/webhook-delivery-lease/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureWebhookDeliveryLeaseModule = void 0;
+const teleport_types_1 = require("@teleporthq/teleport-types");
+const auth_generator_1 = require("../auth-generator");
+const resolve_data_source_1 = require("../invoice/resolve-data-source");
+const webhook_delivery_lease_code_1 = require("./webhook-delivery-lease-code");
+const webhook_delivery_lease_scope_1 = require("./webhook-delivery-lease-scope");
+/**
+ * Writes `utils/workflows/webhook-delivery-lease.js` into the project, once —
+ * called for every payment webhook route, which requires it. Postgres only:
+ * on another data source the module claims nothing, with the same export.
+ */
+const ensureWebhookDeliveryLeaseModule = (structure) => {
+    const { files, dependencies } = structure;
+    if (files.has(webhook_delivery_lease_scope_1.WEBHOOK_DELIVERY_LEASE_FILE_KEY)) {
+        return;
+    }
+    const { dataSourceType } = (0, resolve_data_source_1.resolveInvoiceDataSource)(structure);
+    const driverDeps = (0, auth_generator_1.getDatabaseDriverDependencies)(dataSourceType);
+    const pgSupported = 'pg' in driverDeps;
+    files.set(webhook_delivery_lease_scope_1.WEBHOOK_DELIVERY_LEASE_FILE_KEY, {
+        path: webhook_delivery_lease_scope_1.WEBHOOK_DELIVERY_LEASE_PATH,
+        files: [
+            {
+                name: webhook_delivery_lease_scope_1.WEBHOOK_DELIVERY_LEASE_FILE_NAME,
+                fileType: teleport_types_1.FileType.JS,
+                content: (0, webhook_delivery_lease_code_1.generateWebhookDeliveryLeaseCode)({ pgSupported }),
+            },
+        ],
+    });
+    if (pgSupported) {
+        for (const [pkg, version] of Object.entries(driverDeps)) {
+            if (!dependencies[pkg]) {
+                dependencies[pkg] = version;
+            }
+        }
+    }
+};
+exports.ensureWebhookDeliveryLeaseModule = ensureWebhookDeliveryLeaseModule;
+//# sourceMappingURL=index.js.map

package/dist/cjs/webhook-delivery-lease/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/webhook-delivery-lease/index.ts"],"names":[],"mappings":";;;AAAA,+DAA6E;AAC7E,sDAAiE;AACjE,wEAAyE;AACzE,+EAAgF;AAChF,iFAIuC;AAEvC;;;;GAIG;AACI,MAAM,gCAAgC,GAAG,CAAC,SAAiC,EAAQ,EAAE;IAC1F,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,SAAS,CAAA;IACzC,IAAI,KAAK,CAAC,GAAG,CAAC,8DAA+B,CAAC,EAAE;QAC9C,OAAM;KACP;IAED,MAAM,EAAE,cAAc,EAAE,GAAG,IAAA,8CAAwB,EAAC,SAAS,CAAC,CAAA;IAC9D,MAAM,UAAU,GAAG,IAAA,8CAA6B,EAAC,cAAc,CAAC,CAAA;IAChE,MAAM,WAAW,GAAG,IAAI,IAAI,UAAU,CAAA;IAEtC,KAAK,CAAC,GAAG,CAAC,8DAA+B,EAAE;QACzC,IAAI,EAAE,0DAA2B;QACjC,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,+DAAgC;gBACtC,QAAQ,EAAE,yBAAQ,CAAC,EAAE;gBACrB,OAAO,EAAE,IAAA,8DAAgC,EAAC,EAAE,WAAW,EAAE,CAAC;aAC3D;SACF;KACF,CAAC,CAAA;IAEF,IAAI,WAAW,EAAE;QACf,KAAK,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;YACvD,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE;gBACtB,YAAY,CAAC,GAAG,CAAC,GAAG,OAAO,CAAA;aAC5B;SACF;KACF;AACH,CAAC,CAAA;AA5BY,QAAA,gCAAgC,oCA4B5C"}

package/dist/cjs/webhook-delivery-lease/webhook-delivery-lease-code.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Emits `utils/workflows/webhook-delivery-lease.js` — one payment webhook
+ * delivery at a time.
+ *
+ * A provider re-delivers an event it did not see answered in time (Paddle
+ * waits five seconds; a checkout's chain of writes, emails and an invoice can
+ * take longer), and the second delivery can arrive while the first is still
+ * running. Every step is safe against a replay that comes AFTER the first run
+ * — the order is paid by compare-and-set, events and renewals are keyed — but
+ * two runs side by side can both pass a check before either writes: two
+ * lifecycle emails, two license keys for one unit.
+ *
+ * So a verified delivery claims its body first. The same body arriving while
+ * the claim is held is answered 503 with a Retry-After, and the provider
+ * delivers it again later, when it is an ordinary replay. The claim is
+ * released before the route replies; one left by a run that died expires
+ * after a lease longer than any route may run.
+ *
+ * Contract: `claimWebhookDelivery` never throws. Without Postgres, a driver,
+ * the table or the privilege to create it, it claims nothing and lets the
+ * delivery run — as every delivery ran before the lease existed.
+ */
+export declare const generateWebhookDeliveryLeaseCode: (options: {
+    pgSupported: boolean;
+}) => string;
+//# sourceMappingURL=webhook-delivery-lease-code.d.ts.map

package/dist/cjs/webhook-delivery-lease/webhook-delivery-lease-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-delivery-lease-code.d.ts","sourceRoot":"","sources":["../../../src/webhook-delivery-lease/webhook-delivery-lease-code.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,gCAAgC,YAAa;IAAE,WAAW,EAAE,OAAO,CAAA;CAAE,KAAG,MA0HpF,CAAA"}

package/dist/cjs/webhook-delivery-lease/webhook-delivery-lease-code.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWebhookDeliveryLeaseCode = void 0;
+const pg_client_code_1 = require("../pg-client-code");
+const webhook_delivery_lease_scope_1 = require("./webhook-delivery-lease-scope");
+/**
+ * Emits `utils/workflows/webhook-delivery-lease.js` — one payment webhook
+ * delivery at a time.
+ *
+ * A provider re-delivers an event it did not see answered in time (Paddle
+ * waits five seconds; a checkout's chain of writes, emails and an invoice can
+ * take longer), and the second delivery can arrive while the first is still
+ * running. Every step is safe against a replay that comes AFTER the first run
+ * — the order is paid by compare-and-set, events and renewals are keyed — but
+ * two runs side by side can both pass a check before either writes: two
+ * lifecycle emails, two license keys for one unit.
+ *
+ * So a verified delivery claims its body first. The same body arriving while
+ * the claim is held is answered 503 with a Retry-After, and the provider
+ * delivers it again later, when it is an ordinary replay. The claim is
+ * released before the route replies; one left by a run that died expires
+ * after a lease longer than any route may run.
+ *
+ * Contract: `claimWebhookDelivery` never throws. Without Postgres, a driver,
+ * the table or the privilege to create it, it claims nothing and lets the
+ * delivery run — as every delivery ran before the lease existed.
+ */
+const generateWebhookDeliveryLeaseCode = (options) => {
+    if (!options.pgSupported) {
+        return `/**
+ * Payment webhook delivery lease — disabled: the project's data source is not Postgres.
+ */
+function claimWebhookDelivery() {
+  return Promise.resolve({ claimed: true, release: function () { return Promise.resolve(); } });
+}
+
+module.exports = { claimWebhookDelivery };
+`;
+    }
+    return `/**
+ * Payment webhook delivery lease: one run per delivered body at a time.
+ */
+var crypto = require('crypto');
+${(0, pg_client_code_1.generateLazyPgClientCode)()}
+
+var TABLE_NAME = '${webhook_delivery_lease_scope_1.WEBHOOK_DELIVERY_LEASE_TABLE}';
+var LEASE_SECONDS = ${webhook_delivery_lease_scope_1.WEBHOOK_DELIVERY_LEASE_SECONDS};
+var QUERY_TIMEOUT_MS = 5000;
+var CREATE_SQL = 'CREATE TABLE IF NOT EXISTS "' + TABLE_NAME + '" (' +
+  'delivery_key TEXT PRIMARY KEY, claim_token TEXT NOT NULL, ' +
+  'claimed_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), attempts INTEGER NOT NULL DEFAULT 1)';
+// Taken over only once the holder's lease ran out: a run that died.
+var CLAIM_SQL = 'INSERT INTO "' + TABLE_NAME + '" AS d (delivery_key, claim_token) VALUES ($1, $2) ' +
+  'ON CONFLICT (delivery_key) DO UPDATE SET claim_token = EXCLUDED.claim_token, claimed_at = NOW(), attempts = d.attempts + 1 ' +
+  'WHERE d.claimed_at < NOW() - make_interval(secs => $3::int) RETURNING d.claim_token';
+// Only this run's own claim, and whatever a dead run left a day ago.
+var RELEASE_SQL = 'DELETE FROM "' + TABLE_NAME + '" WHERE (delivery_key = $1 AND claim_token = $2) ' +
+  "OR claimed_at < NOW() - INTERVAL '1 day'";
+
+var __tableReady = false;
+var __disabledReason = '';
+
+function __disable(reason) {
+  if (__disabledReason) return;
+  __disabledReason = reason;
+  console.warn('[webhook-delivery-lease] disabled for this process: ' + reason);
+}
+
+function __hasDatabaseEnv() {
+  return !!(process.env.TELEPORT_DB_CONNECTION_STRING || process.env.TELEPORT_DB_HOST);
+}
+
+function __withTimeout(promise, ms) {
+  var timer;
+  var timeout = new Promise(function (_resolve, reject) {
+    timer = setTimeout(function () { reject(new Error('webhook-delivery-lease query timed out after ' + ms + 'ms')); }, ms);
+  });
+  return Promise.race([promise, timeout]).then(function (v) { clearTimeout(timer); return v; }, function (err) { clearTimeout(timer); throw err; });
+}
+
+async function __run(statements) {
+  var client = getClient();
+  await __withTimeout(client.connect(), QUERY_TIMEOUT_MS);
+  try {
+    var result = null;
+    for (var i = 0; i < statements.length; i++) {
+      result = await __withTimeout(client.query(statements[i].sql, statements[i].values), QUERY_TIMEOUT_MS);
+    }
+    return result;
+  } finally {
+    try { await client.end(); } catch (_e) {}
+  }
+}
+
+function __stableJson(value) {
+  try { return JSON.stringify(value === undefined ? null : value) || ''; } catch (_e) { return ''; }
+}
+
+function __unheld() {
+  return { claimed: true, release: function () { return Promise.resolve(); } };
+}
+
+/**
+ * Claims one delivery: \`scope\` names the webhook, \`rawBody\` is what the
+ * provider sent and \`verifiedBody\` the event it was verified as — a provider
+ * that posts only an id (Mollie, CoinGate) posts the same body for every
+ * change, and the state fetched for it tells two changes apart. Resolves
+ * \`{ claimed, release }\`; \`claimed: false\` means the same delivery is
+ * running right now. \`release\` never rejects.
+ */
+async function claimWebhookDelivery(scope, rawBody, verifiedBody) {
+  if (__disabledReason || !__hasDatabaseEnv() || !__loadPg()) return __unheld();
+  var key = crypto.createHash('sha256')
+    .update(String(scope || ''))
+    .update('\\n')
+    .update(Buffer.isBuffer(rawBody) ? rawBody : String(rawBody == null ? '' : rawBody))
+    .update('\\n')
+    .update(__stableJson(verifiedBody))
+    .digest('hex');
+  var token = crypto.randomBytes(16).toString('hex');
+  var statements = __tableReady ? [] : [{ sql: CREATE_SQL, values: [] }];
+  statements.push({ sql: CLAIM_SQL, values: [key, token, LEASE_SECONDS] });
+  var result;
+  try {
+    result = await __run(statements);
+    __tableReady = true;
+  } catch (err) {
+    var code = err && err.code;
+    if (code === '42501') { __disable('no privilege to create or write table ' + TABLE_NAME); }
+    else { console.error('[webhook-delivery-lease] claim failed: ' + (err && err.message ? err.message : String(err))); }
+    return __unheld();
+  }
+  if (!result || !Array.isArray(result.rows) || result.rows.length === 0) {
+    return { claimed: false, release: function () { return Promise.resolve(); } };
+  }
+  return {
+    claimed: true,
+    release: function () {
+      return __run([{ sql: RELEASE_SQL, values: [key, token] }]).then(
+        function () {},
+        function (err) { console.error('[webhook-delivery-lease] release failed: ' + (err && err.message ? err.message : String(err))); }
+      );
+    },
+  };
+}
+
+module.exports = { claimWebhookDelivery };
+`;
+};
+exports.generateWebhookDeliveryLeaseCode = generateWebhookDeliveryLeaseCode;
+//# sourceMappingURL=webhook-delivery-lease-code.js.map

package/dist/cjs/webhook-delivery-lease/webhook-delivery-lease-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-delivery-lease-code.js","sourceRoot":"","sources":["../../../src/webhook-delivery-lease/webhook-delivery-lease-code.ts"],"names":[],"mappings":";;;AAAA,sDAA4D;AAC5D,iFAGuC;AAEvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACI,MAAM,gCAAgC,GAAG,CAAC,OAAiC,EAAU,EAAE;IAC5F,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;QACxB,OAAO;;;;;;;;CAQV,CAAA;KACE;IAED,OAAO;;;;EAIP,IAAA,yCAAwB,GAAE;;oBAER,2DAA4B;sBAC1B,6DAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqGnD,CAAA;AACD,CAAC,CAAA;AA1HY,QAAA,gCAAgC,oCA0H5C"}

package/dist/cjs/webhook-delivery-lease/webhook-delivery-lease-scope.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Where the payment webhook delivery lease lives in the generated project
+ * (`utils/workflows/webhook-delivery-lease.js`), and the table it keeps.
+ */
+export declare const WEBHOOK_DELIVERY_LEASE_FILE_KEY = "webhook-delivery-lease";
+export declare const WEBHOOK_DELIVERY_LEASE_PATH: string[];
+export declare const WEBHOOK_DELIVERY_LEASE_FILE_NAME = "webhook-delivery-lease";
+export declare const WEBHOOK_DELIVERY_LEASE_TABLE = "teleport_webhook_deliveries";
+/**
+ * How long a claim holds before another delivery may take it over: longer
+ * than any route may run, so a claim is only ever taken from a run that died.
+ */
+export declare const WEBHOOK_DELIVERY_LEASE_SECONDS = 300;
+/** What a delivery that finds its twin still running is told to wait, in seconds. */
+export declare const WEBHOOK_DELIVERY_RETRY_AFTER_SECONDS = 60;
+//# sourceMappingURL=webhook-delivery-lease-scope.d.ts.map

package/dist/cjs/webhook-delivery-lease/webhook-delivery-lease-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-delivery-lease-scope.d.ts","sourceRoot":"","sources":["../../../src/webhook-delivery-lease/webhook-delivery-lease-scope.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,+BAA+B,2BAA2B,CAAA;AACvE,eAAO,MAAM,2BAA2B,UAAyB,CAAA;AACjE,eAAO,MAAM,gCAAgC,2BAA2B,CAAA;AACxE,eAAO,MAAM,4BAA4B,gCAAgC,CAAA;AAEzE;;;GAGG;AACH,eAAO,MAAM,8BAA8B,MAAM,CAAA;AAEjD,qFAAqF;AACrF,eAAO,MAAM,oCAAoC,KAAK,CAAA"}

package/dist/cjs/webhook-delivery-lease/webhook-delivery-lease-scope.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Where the payment webhook delivery lease lives in the generated project
+ * (`utils/workflows/webhook-delivery-lease.js`), and the table it keeps.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEBHOOK_DELIVERY_RETRY_AFTER_SECONDS = exports.WEBHOOK_DELIVERY_LEASE_SECONDS = exports.WEBHOOK_DELIVERY_LEASE_TABLE = exports.WEBHOOK_DELIVERY_LEASE_FILE_NAME = exports.WEBHOOK_DELIVERY_LEASE_PATH = exports.WEBHOOK_DELIVERY_LEASE_FILE_KEY = void 0;
+exports.WEBHOOK_DELIVERY_LEASE_FILE_KEY = 'webhook-delivery-lease';
+exports.WEBHOOK_DELIVERY_LEASE_PATH = ['utils', 'workflows'];
+exports.WEBHOOK_DELIVERY_LEASE_FILE_NAME = 'webhook-delivery-lease';
+exports.WEBHOOK_DELIVERY_LEASE_TABLE = 'teleport_webhook_deliveries';
+/**
+ * How long a claim holds before another delivery may take it over: longer
+ * than any route may run, so a claim is only ever taken from a run that died.
+ */
+exports.WEBHOOK_DELIVERY_LEASE_SECONDS = 300;
+/** What a delivery that finds its twin still running is told to wait, in seconds. */
+exports.WEBHOOK_DELIVERY_RETRY_AFTER_SECONDS = 60;
+//# sourceMappingURL=webhook-delivery-lease-scope.js.map

package/dist/cjs/webhook-delivery-lease/webhook-delivery-lease-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-delivery-lease-scope.js","sourceRoot":"","sources":["../../../src/webhook-delivery-lease/webhook-delivery-lease-scope.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEU,QAAA,+BAA+B,GAAG,wBAAwB,CAAA;AAC1D,QAAA,2BAA2B,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAA;AACpD,QAAA,gCAAgC,GAAG,wBAAwB,CAAA;AAC3D,QAAA,4BAA4B,GAAG,6BAA6B,CAAA;AAEzE;;;GAGG;AACU,QAAA,8BAA8B,GAAG,GAAG,CAAA;AAEjD,qFAAqF;AACxE,QAAA,oCAAoC,GAAG,EAAE,CAAA"}

package/dist/cjs/webhook-generator.d.ts

@@ -2,7 +2,7 @@ import { ProjectPluginStructure, UIDLInvoiceSettings, UIDLEcommerceSettings } fr
 export declare const generateStripeWebhookCode: (invoiceSettings: UIDLInvoiceSettings | undefined, ecommerceSettings?: UIDLEcommerceSettings) => string;
 export declare const generatePaypalWebhookCode: (invoiceSettings: UIDLInvoiceSettings | undefined, ecommerceSettings?: UIDLEcommerceSettings) => string;
 export interface GenerateWebhookFilesOptions {
-    skipProviders?: Set<'stripe' | 'paypal'>;
+    skipProviders?: ReadonlySet<string>;
 }
 export declare const generateWebhookFiles: (structure: ProjectPluginStructure, invoiceSettings: UIDLInvoiceSettings | undefined, options?: GenerateWebhookFilesOptions) => void;
 //# sourceMappingURL=webhook-generator.d.ts.map

package/dist/cjs/webhook-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webhook-generator.d.ts","sourceRoot":"","sources":["../../src/webhook-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EAEtB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,4BAA4B,CAAA;AAEnC,eAAO,MAAM,yBAAyB,oBACnB,mBAAmB,GAAG,SAAS,sBAC5B,qBAAqB,KACxC,MAyMF,CAAA;AAyQD,eAAO,MAAM,yBAAyB,oBACnB,mBAAmB,GAAG,SAAS,sBAC5B,qBAAqB,KACxC,MAsYF,CAAA;AAED,MAAM,WAAW,2BAA2B;IAK1C,aAAa,CAAC,EAAE,GAAG,CAAC,QAAQ,GAAG,QAAQ,CAAC,CAAA;CACzC;AAED,eAAO,MAAM,oBAAoB,cACpB,sBAAsB,mBAChB,mBAAmB,GAAG,SAAS,YACvC,2BAA2B,KACnC,IA2CF,CAAA"}
+{"version":3,"file":"webhook-generator.d.ts","sourceRoot":"","sources":["../../src/webhook-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EAEtB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,4BAA4B,CAAA;AAyCnC,eAAO,MAAM,yBAAyB,oBACnB,mBAAmB,GAAG,SAAS,sBAC5B,qBAAqB,KACxC,MA8LF,CAAA;AAgUD,eAAO,MAAM,yBAAyB,oBACnB,mBAAmB,GAAG,SAAS,sBAC5B,qBAAqB,KACxC,MAsYF,CAAA;AAED,MAAM,WAAW,2BAA2B;IAK1C,aAAa,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACpC;AAED,eAAO,MAAM,oBAAoB,cACpB,sBAAsB,mBAChB,mBAAmB,GAAG,SAAS,YACvC,2BAA2B,KACnC,IA2DF,CAAA"}