@hostwebhook/node-types 1.82.0 → 1.84.0

package/dist/esm/airtable-operations.js

@@ -0,0 +1,270 @@
+/**
+ * El nodo de Airtable: leer y escribir records de una tabla.
+ *
+ * ## Por qué existe
+ *
+ * [2026-09-15] Airtable expone una API REST con OAuth 2.0 (PKCE obligatorio,
+ * refresh que rota) y webhooks. Es «la hoja de cálculo con tipos» que mucha
+ * gente usa de base de datos ligera, así que este nodo se parece más a
+ * Postgres/Sheets que a un servicio de mensajería: casi todo es CRUD sobre
+ * una tabla.
+ *
+ * ## Cómo se nombra todo
+ *
+ * Una base es `appXXXXXXXXXXXXXX`, una tabla `tblXXXXXXXXXXXXXX`, una vista
+ * `viwXXXXXXXXXXXXXX`, un record `recXXXXXXXXXXXXXX`. Base y tabla se eligen
+ * en desplegables que lee el esquema (`GET /v0/meta/bases`,
+ * `GET /v0/meta/bases/{baseId}/tables`), y **los campos se escriben por
+ * nombre**, que es como los ve el usuario en Airtable. El esquema trae tipo
+ * y opciones de cada campo, y el editor de campos los usa para ofrecer lo
+ * que cabe: las opciones de un select, el formato de una fecha.
+ *
+ * ## Uno o un lote
+ *
+ * Cada operación de escritura trabaja sobre UN record —el caso normal, con
+ * el Loop node repitiendo si hacen falta varios— y tiene en Advanced un
+ * «Batch» que acepta un array del payload. Airtable admite 10 por llamada y
+ * 5 llamadas por segundo por base; el servicio trocea y espera, el usuario
+ * no tiene que saberlo.
+ *
+ * ## Por qué ocho
+ *
+ * Las seis de records (listar, uno, crear, editar, upsert, borrar) más las
+ * dos de esquema que un flujo puede necesitar (bases, tablas y campos).
+ * Fuera a propósito: comentarios, crear tablas o campos, y los webhooks,
+ * que son del trigger.
+ *
+ * ⚠️ El orden de este array es el orden del desplegable.
+ */
+export const AIRTABLE_OPERATIONS = [
+    "listRecords",
+    "getRecord",
+    "createRecord",
+    "updateRecord",
+    "upsertRecord",
+    "deleteRecord",
+    "listBases",
+    "getBaseSchema",
+];
+export function isAirtableOperation(value) {
+    return (typeof value === "string" &&
+        AIRTABLE_OPERATIONS.includes(value));
+}
+/**
+ * Las que devuelven una COLECCIÓN sobre la que el nodo de abajo repite. Cada
+ * una itera SU campo (`iterateField`): `records`, `bases`, `tables`. La
+ * salida lleva `_meta.iterable: true`.
+ */
+export const AIRTABLE_ITERABLE_OPERATIONS = [
+    "listRecords",
+    "listBases",
+    "getBaseSchema",
+];
+const baseId = () => ({
+    name: "baseId",
+    label: "Base",
+    type: "base",
+    required: true,
+    description: "One of the bases the credential was granted access to.",
+});
+const tableId = () => ({
+    name: "tableId",
+    label: "Table",
+    type: "table",
+    required: true,
+    description: "A table in that base.",
+});
+const recordId = () => ({
+    name: "recordId",
+    label: "Record",
+    type: "template",
+    required: true,
+    placeholder: "{{payload.recordId}}",
+    description: "The record's ID (rec…), usually from an Airtable trigger or an earlier step.",
+});
+/* Los valores por nombre de campo. Cadenas con plantilla; el resto (números,
+   checkboxes, arrays de un multi-select o de linked records) como JSON. */
+const fields = () => ({
+    name: "fields",
+    label: "Fields",
+    type: "fields",
+    description: "The values to write, by field name. Strings may use {{payload.x}}; select options, dates and linked records follow the field's type.",
+});
+/* `typecast` convierte "Sí" en un checkbox y "Done" en la opción de un
+   select aunque no exista todavía. Activado por defecto porque es lo que
+   uno espera al escribir desde un flujo; se puede apagar. */
+const typecast = () => ({
+    name: "typecast",
+    label: "Convert values to the field's type",
+    type: "booleanSelect",
+    options: [
+        { value: "true", label: "Yes — text becomes the right type, new select options are created" },
+        { value: "false", label: "No — values must already match the field's type" },
+    ],
+    default: "true",
+    advanced: true,
+    description: "Airtable's typecast: with Yes, \"Yes\" fills a checkbox and an unknown option is added to a select.",
+});
+export const AIRTABLE_OPERATION_SPECS = {
+    listRecords: {
+        label: "List records",
+        description: "Records of a table, optionally through a view and a filter formula. Comes back as the table shows them: fields by name.",
+        apiRoute: "GET /v0/{baseId}/{tableId}",
+        iterateField: "records",
+        params: [
+            baseId(),
+            tableId(),
+            {
+                name: "viewId",
+                label: "View",
+                type: "view",
+                description: "Only the records in this view, in the view's order. Empty = the whole table.",
+            },
+            {
+                name: "filterByFormula",
+                label: "Filter formula",
+                type: "textarea",
+                placeholder: '{Status} = "Done"',
+                description: "An Airtable formula; only records where it is true come back. Field names in braces. Supports {{payload.x}}.",
+            },
+            {
+                name: "fields",
+                label: "Only these fields",
+                type: "fieldList",
+                advanced: true,
+                description: "Fields to include in each record. Empty = every field.",
+            },
+            {
+                name: "sortField",
+                label: "Sort by",
+                type: "field",
+                advanced: true,
+                description: "A field to order by. Empty = the view's order, or the table's.",
+            },
+            {
+                name: "sortDirection",
+                label: "Direction",
+                type: "select",
+                options: [
+                    { value: "asc", label: "Ascending" },
+                    { value: "desc", label: "Descending" },
+                ],
+                default: "asc",
+                advanced: true,
+            },
+            {
+                name: "maxRecords",
+                label: "Max records",
+                type: "number",
+                min: 1,
+                max: 1000,
+                default: 100,
+                advanced: true,
+                description: "How many to bring into the flow, at most (Airtable pages by 100; the node keeps asking). Default 100.",
+            },
+        ],
+    },
+    getRecord: {
+        label: "Get record",
+        description: "One record by its ID, with every field.",
+        apiRoute: "GET /v0/{baseId}/{tableId}/{recordId}",
+        params: [baseId(), tableId(), recordId()],
+    },
+    createRecord: {
+        label: "Create record",
+        description: "Adds a record with the values you give it. For many at once, put an array in Batch (Advanced) — Airtable takes 10 per call and the node paces it.",
+        apiRoute: "POST /v0/{baseId}/{tableId}",
+        params: [
+            baseId(),
+            tableId(),
+            fields(),
+            {
+                name: "records",
+                label: "Batch",
+                type: "json",
+                placeholder: "{{payload.rows}}",
+                advanced: true,
+                description: "An array of objects, each { \"Field\": value, … } — e.g. {{payload.rows}}. When set, Fields above is ignored.",
+            },
+            typecast(),
+        ],
+    },
+    updateRecord: {
+        label: "Update record",
+        description: "Changes the fields you give it and leaves the rest as they are. For many at once, put an array in Batch (Advanced).",
+        apiRoute: "PATCH /v0/{baseId}/{tableId}",
+        params: [
+            baseId(),
+            tableId(),
+            recordId(),
+            fields(),
+            {
+                name: "records",
+                label: "Batch",
+                type: "json",
+                placeholder: "{{payload.rows}}",
+                advanced: true,
+                description: "An array of { \"id\": \"rec…\", \"fields\": { … } } objects. When set, Record and Fields above are ignored.",
+            },
+            typecast(),
+        ],
+    },
+    upsertRecord: {
+        label: "Upsert record",
+        description: "Finds a record by the fields you merge on and updates it; creates it when there is none. Fails if more than one matches.",
+        apiRoute: "PATCH /v0/{baseId}/{tableId} (performUpsert)",
+        params: [
+            baseId(),
+            tableId(),
+            {
+                name: "mergeOn",
+                label: "Match on",
+                type: "fieldList",
+                required: true,
+                description: "One to three fields that identify the record — an email, an external ID. Text, number, select or date fields; not formulas.",
+            },
+            fields(),
+            {
+                name: "records",
+                label: "Batch",
+                type: "json",
+                placeholder: "{{payload.rows}}",
+                advanced: true,
+                description: "An array of objects, each { \"Field\": value, … }. When set, Fields above is ignored.",
+            },
+            typecast(),
+        ],
+    },
+    deleteRecord: {
+        label: "Delete record",
+        description: "Deletes a record. For many at once, put their IDs in Batch (Advanced).",
+        apiRoute: "DELETE /v0/{baseId}/{tableId}",
+        params: [
+            baseId(),
+            tableId(),
+            recordId(),
+            {
+                name: "recordIds",
+                label: "Batch",
+                type: "template",
+                placeholder: "{{payload.ids}}",
+                advanced: true,
+                description: "Record IDs to delete — an array from the payload, or comma-separated. When set, Record above is ignored.",
+            },
+        ],
+    },
+    listBases: {
+        label: "List bases",
+        description: "The bases this credential can reach, with their IDs and your permission level in each.",
+        apiRoute: "GET /v0/meta/bases",
+        iterateField: "bases",
+        params: [],
+    },
+    getBaseSchema: {
+        label: "Get base schema",
+        description: "The tables of a base with their fields (name, type, options) and views. What a flow reads before writing into a table it does not know.",
+        apiRoute: "GET /v0/meta/bases/{baseId}/tables",
+        iterateField: "tables",
+        params: [baseId()],
+    },
+};

package/dist/esm/calendly-operations.d.ts

@@ -0,0 +1,76 @@
+/**
+ * El nodo de Calendly: lo que pasa alrededor de una reserva.
+ *
+ * ## Por qué existe
+ *
+ * [2026-09-15] Calendly expone una API v2 con OAuth 2.0 (PKCE + secret,
+ * refresh de un solo uso) y webhooks firmados. La reserva en sí la hace el
+ * invitado en Calendly; lo que HostWebhook necesita es leerla (el trigger la
+ * trae; este nodo la consulta), cancelarla, marcar el no-show, y las dos
+ * que cierran el círculo: un link de reserva que caduca al usarse y los
+ * huecos libres de un tipo de evento, para que un agente los ofrezca.
+ *
+ * ## Cómo se nombra todo
+ *
+ * Calendly identifica cada cosa por su URI completa
+ * (`https://api.calendly.com/scheduled_events/ABC…`), no por un id corto.
+ * Los parámetros que piden una la aceptan entera o sólo el uuid final; el
+ * servicio completa el prefijo. Los que piden «Mine / Whole organization»
+ * resuelven al `owner` y `organization` que la credencial guardó al
+ * conectar, así que el usuario no escribe URIs nunca.
+ *
+ * ## Por qué nueve
+ *
+ * Eventos (listar, uno, invitados, cancelar), no-show (poner y quitar),
+ * tipos de evento (listar), huecos libres y link de un solo uso. Fuera a
+ * propósito: crear tipos de evento, contactos, routing forms, recaps y toda
+ * la gestión de organización —nada de eso es «lo que pasa alrededor de una
+ * reserva». Los webhooks van en el trigger, no aquí.
+ *
+ * ⚠️ El orden de este array es el orden del desplegable.
+ */
+export declare const CALENDLY_OPERATIONS: readonly ["listEvents", "getEvent", "listInvitees", "cancelEvent", "markNoShow", "undoNoShow", "listEventTypes", "getAvailableTimes", "createSchedulingLink"];
+export type CalendlyOperation = (typeof CALENDLY_OPERATIONS)[number];
+export declare function isCalendlyOperation(value: unknown): value is CalendlyOperation;
+/**
+ * Las que devuelven una COLECCIÓN sobre la que el nodo de abajo repite. Cada
+ * una itera SU campo (`iterateField` en la spec): `events`, `invitees`,
+ * `eventTypes`, `slots`. La salida lleva `_meta.iterable: true`.
+ */
+export declare const CALENDLY_ITERABLE_OPERATIONS: ReadonlyArray<CalendlyOperation>;
+/**
+ * Tipos de parámetro. Los seis primeros son los de Apify. Los dos nuevos:
+ *
+ * - `datetime`: una fecha con hora, ISO 8601, en la zona horaria del
+ *   usuario; el dashboard la pinta con el selector de Calendar y admite
+ *   plantilla (`{{payload.startTime}}`).
+ * - `eventType`: un desplegable que lista los tipos de evento de la
+ *   credencial (`GET /calendly-actions/event-types`); el valor es la URI del
+ *   tipo. Admite plantilla para cuando viene del payload.
+ */
+export type CalendlyParamType = "template" | "textarea" | "json" | "select" | "number" | "booleanSelect" | "datetime" | "eventType";
+export interface CalendlyParamSpec {
+    name: string;
+    label: string;
+    type: CalendlyParamType;
+    required?: boolean;
+    description?: string;
+    placeholder?: string;
+    default?: string | number;
+    options?: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>;
+    min?: number;
+    max?: number;
+    advanced?: boolean;
+}
+export interface CalendlyOperationSpec {
+    label: string;
+    description: string;
+    apiRoute: string;
+    params: CalendlyParamSpec[];
+    /** El campo de la salida que se itera; sólo en las iterables. */
+    iterateField?: string;
+}
+export declare const CALENDLY_OPERATION_SPECS: Record<CalendlyOperation, CalendlyOperationSpec>;

package/dist/esm/calendly-operations.js

@@ -0,0 +1,285 @@
+/**
+ * El nodo de Calendly: lo que pasa alrededor de una reserva.
+ *
+ * ## Por qué existe
+ *
+ * [2026-09-15] Calendly expone una API v2 con OAuth 2.0 (PKCE + secret,
+ * refresh de un solo uso) y webhooks firmados. La reserva en sí la hace el
+ * invitado en Calendly; lo que HostWebhook necesita es leerla (el trigger la
+ * trae; este nodo la consulta), cancelarla, marcar el no-show, y las dos
+ * que cierran el círculo: un link de reserva que caduca al usarse y los
+ * huecos libres de un tipo de evento, para que un agente los ofrezca.
+ *
+ * ## Cómo se nombra todo
+ *
+ * Calendly identifica cada cosa por su URI completa
+ * (`https://api.calendly.com/scheduled_events/ABC…`), no por un id corto.
+ * Los parámetros que piden una la aceptan entera o sólo el uuid final; el
+ * servicio completa el prefijo. Los que piden «Mine / Whole organization»
+ * resuelven al `owner` y `organization` que la credencial guardó al
+ * conectar, así que el usuario no escribe URIs nunca.
+ *
+ * ## Por qué nueve
+ *
+ * Eventos (listar, uno, invitados, cancelar), no-show (poner y quitar),
+ * tipos de evento (listar), huecos libres y link de un solo uso. Fuera a
+ * propósito: crear tipos de evento, contactos, routing forms, recaps y toda
+ * la gestión de organización —nada de eso es «lo que pasa alrededor de una
+ * reserva». Los webhooks van en el trigger, no aquí.
+ *
+ * ⚠️ El orden de este array es el orden del desplegable.
+ */
+export const CALENDLY_OPERATIONS = [
+    "listEvents",
+    "getEvent",
+    "listInvitees",
+    "cancelEvent",
+    "markNoShow",
+    "undoNoShow",
+    "listEventTypes",
+    "getAvailableTimes",
+    "createSchedulingLink",
+];
+export function isCalendlyOperation(value) {
+    return (typeof value === "string" &&
+        CALENDLY_OPERATIONS.includes(value));
+}
+/**
+ * Las que devuelven una COLECCIÓN sobre la que el nodo de abajo repite. Cada
+ * una itera SU campo (`iterateField` en la spec): `events`, `invitees`,
+ * `eventTypes`, `slots`. La salida lleva `_meta.iterable: true`.
+ */
+export const CALENDLY_ITERABLE_OPERATIONS = [
+    "listEvents",
+    "listInvitees",
+    "listEventTypes",
+    "getAvailableTimes",
+];
+/* «Mine» es el usuario que conectó; «Whole organization» exige ser admin u
+   owner en Calendly, y si no lo es la API contesta 403 y el nodo lo dice. */
+const owner = () => ({
+    name: "owner",
+    label: "Whose",
+    type: "select",
+    options: [
+        { value: "mine", label: "Mine — the connected user" },
+        { value: "organization", label: "Whole organization (admins only)" },
+    ],
+    default: "mine",
+    description: "Mine uses the account that connected the credential. Whole organization needs an organization admin or owner.",
+});
+/* Un evento se nombra por su URI o por el uuid del final; da igual. */
+const eventUri = () => ({
+    name: "eventUri",
+    label: "Event",
+    type: "template",
+    required: true,
+    placeholder: "{{payload.event.uri}}",
+    description: "The scheduled event — its URI, or just the ID at the end of it. Usually {{payload.event.uri}} from a Calendly trigger.",
+});
+const eventType = () => ({
+    name: "eventType",
+    label: "Event type",
+    type: "eventType",
+    required: true,
+    description: "One of the event types on the connected account (e.g. “30 min intro call”).",
+});
+const pageLimit = (max, fallback) => ({
+    name: "limit",
+    label: "Max results",
+    type: "number",
+    min: 1,
+    max,
+    default: fallback,
+    advanced: true,
+    description: `How many to bring into the flow, at most. Default ${fallback}.`,
+});
+export const CALENDLY_OPERATION_SPECS = {
+    listEvents: {
+        label: "List events",
+        description: "Scheduled events in a time window — yours or the whole organization's. Each one comes with its event type, hosts and location; invitees are a separate step.",
+        apiRoute: "GET /scheduled_events",
+        iterateField: "events",
+        params: [
+            owner(),
+            {
+                name: "status",
+                label: "Status",
+                type: "select",
+                options: [
+                    { value: "active", label: "Active — upcoming and past, not canceled" },
+                    { value: "canceled", label: "Canceled" },
+                    { value: "all", label: "All" },
+                ],
+                default: "active",
+            },
+            {
+                name: "minStartTime",
+                label: "Starting from",
+                type: "datetime",
+                placeholder: "{{payload.from}}",
+                description: "Only events that start at or after this moment. Empty = no lower bound.",
+            },
+            {
+                name: "maxStartTime",
+                label: "Starting before",
+                type: "datetime",
+                placeholder: "{{payload.to}}",
+                description: "Only events that start before this moment. Empty = no upper bound.",
+            },
+            {
+                name: "inviteeEmail",
+                label: "Invitee email",
+                type: "template",
+                placeholder: "{{payload.email}}",
+                advanced: true,
+                description: "Only events booked by this email. Empty = everyone.",
+            },
+            {
+                name: "sort",
+                label: "Order",
+                type: "select",
+                options: [
+                    { value: "start_time:asc", label: "Soonest first" },
+                    { value: "start_time:desc", label: "Latest first" },
+                ],
+                default: "start_time:asc",
+                advanced: true,
+            },
+            pageLimit(500, 100),
+        ],
+    },
+    getEvent: {
+        label: "Get event",
+        description: "One scheduled event by its URI: name, start and end, event type, hosts, location, and how many invitees it has.",
+        apiRoute: "GET /scheduled_events/{uuid}",
+        params: [eventUri()],
+    },
+    listInvitees: {
+        label: "List invitees",
+        description: "Who booked an event: name, email, timezone, their answers to the booking questions, and whether they canceled or rescheduled.",
+        apiRoute: "GET /scheduled_events/{uuid}/invitees",
+        iterateField: "invitees",
+        params: [
+            eventUri(),
+            {
+                name: "status",
+                label: "Status",
+                type: "select",
+                options: [
+                    { value: "active", label: "Active" },
+                    { value: "canceled", label: "Canceled" },
+                    { value: "all", label: "All" },
+                ],
+                default: "all",
+                advanced: true,
+            },
+            {
+                name: "inviteeEmail",
+                label: "Invitee email",
+                type: "template",
+                placeholder: "{{payload.email}}",
+                advanced: true,
+                description: "Only the invitee with this email. Empty = all of them.",
+            },
+            pageLimit(100, 100),
+        ],
+    },
+    cancelEvent: {
+        label: "Cancel event",
+        description: "Cancels a scheduled event and notifies its invitees, the same way the host would from Calendly.",
+        apiRoute: "POST /scheduled_events/{uuid}/cancellation",
+        params: [
+            eventUri(),
+            {
+                name: "reason",
+                label: "Reason",
+                type: "textarea",
+                placeholder: "Sorry — something came up. Please rebook with the link below.",
+                description: "Shown to the invitees in the cancellation email. Supports {{payload.x}}. Empty = no reason.",
+            },
+        ],
+    },
+    markNoShow: {
+        label: "Mark invitee as no-show",
+        description: "Marks an invitee as a no-show on a past event. Returns the no-show record; keep its URI if you may need to undo it.",
+        apiRoute: "POST /invitee_no_shows",
+        params: [
+            {
+                name: "inviteeUri",
+                label: "Invitee",
+                type: "template",
+                required: true,
+                placeholder: "{{payload.invitee.uri}}",
+                description: "The invitee — its URI, from List invitees or a Calendly trigger.",
+            },
+        ],
+    },
+    undoNoShow: {
+        label: "Undo no-show",
+        description: "Removes a no-show mark. Takes the URI that Mark invitee as no-show returned.",
+        apiRoute: "DELETE /invitee_no_shows/{uuid}",
+        params: [
+            {
+                name: "noShowUri",
+                label: "No-show",
+                type: "template",
+                required: true,
+                placeholder: "{{payload.uri}}",
+                description: "The no-show record to remove — its URI, or just the ID at the end.",
+            },
+        ],
+    },
+    listEventTypes: {
+        label: "List event types",
+        description: "The event types you (or the organization) offer: name, duration, scheduling URL, and whether they are active. What you need before asking for available times or a link.",
+        apiRoute: "GET /event_types",
+        iterateField: "eventTypes",
+        params: [
+            owner(),
+            {
+                name: "activeOnly",
+                label: "Active only",
+                type: "booleanSelect",
+                options: [
+                    { value: "true", label: "Yes — only event types that can be booked" },
+                    { value: "false", label: "No — include hidden and inactive ones" },
+                ],
+                default: "true",
+                advanced: true,
+            },
+            pageLimit(100, 100),
+        ],
+    },
+    getAvailableTimes: {
+        label: "Get available times",
+        description: "The free slots of an event type in a window of up to 7 days, each with its start time and a scheduling URL that books exactly that slot. Made for an agent that offers times.",
+        apiRoute: "GET /event_type_available_times",
+        iterateField: "slots",
+        params: [
+            eventType(),
+            {
+                name: "startTime",
+                label: "From",
+                type: "datetime",
+                required: true,
+                placeholder: "{{payload.from}}",
+                description: "Start of the window. Must be in the future.",
+            },
+            {
+                name: "endTime",
+                label: "To",
+                type: "datetime",
+                required: true,
+                placeholder: "{{payload.to}}",
+                description: "End of the window — at most 7 days after From. A longer window is cut to 7 days.",
+            },
+        ],
+    },
+    createSchedulingLink: {
+        label: "Create single-use scheduling link",
+        description: "A booking link for one event type that stops working after one booking. Send it to someone instead of your public link.",
+        apiRoute: "POST /scheduling_links",
+        params: [eventType()],
+    },
+};

package/dist/esm/connections.js

@@ -75,6 +75,8 @@ export const NODE_CONNECTIONS = {
     jiraAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
     bucketAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
     apifyAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
+    calendlyAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
+    airtableAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
     googleContactsAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
     googleAnalyticsAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
     notionAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: PROCESSING_OUTPUTS },

package/dist/esm/credentials.d.ts

@@ -72,6 +72,12 @@ export declare const CREDENTIAL_TYPES: readonly [{
     readonly type: "firecrawl";
 }, {
     readonly type: "apify";
+}, {
+    readonly type: "calendly_oauth2";
+}, {
+    readonly type: "calendly";
+}, {
+    readonly type: "airtable_oauth2";
 }, {
     readonly type: "http_auth";
 }, {

package/dist/esm/credentials.js

@@ -53,6 +53,26 @@ export const CREDENTIAL_TYPES = [
     /* [2026-09-13] Apify no tiene OAuth para terceros: es un API token, como
        Firecrawl. Lo lee el nodo `apifyAction`. */
     { type: 'apify' },
+    /* [2026-09-15] El OAuth de HostWebhook contra Calendly. Se anota ANTES de
+       escribir el servicio, por lo que cuenta el bloque de Mailchimp de abajo:
+       sin esta línea el `create` de la credencial muere en runtime con un enum
+       de Mongoose que TypeScript no ve. Lleva `_oauth2` como Mailchimp y
+       Shopify. Guarda, además de los tokens, el `owner` y la `organization`
+       (URIs) que el token endpoint devuelve: cada lista y cada webhook los
+       necesita. El refresh token es de UN solo uso: se sobreescribe en el
+       mismo write que lo gasta. */
+    { type: 'calendly_oauth2' },
+    /* El personal access token de Calendly (Integrations → API & webhooks),
+       para quien no quiera OAuth. Va aparte de `calendly_oauth2` por lo mismo
+       que `discord_bot` va aparte de `discord_oauth`: lo que guardan es
+       distinto (aquí un secreto suyo que no caduca y ninguna URI hasta que se
+       valida con `GET /users/me`). */
+    { type: 'calendly' },
+    /* El OAuth de HostWebhook contra Airtable. PKCE obligatorio, secret por
+       Basic auth, access token de 60 minutos y refresh de 60 días que rota
+       en cada uso. El usuario elige en la pantalla de Airtable QUÉ bases
+       concede; los desplegables sólo listan ésas. */
+    { type: 'airtable_oauth2' },
     { type: 'http_auth' },
     { type: 'aws_s3' },
     /* [2026-09-14] `memory_contextwindow` se retiró: el backend de memoria