@hostwebhook/node-types 1.83.0 → 1.85.0

package/dist/calendly-operations.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CALENDLY_OPERATION_SPECS = exports.CALENDLY_ITERABLE_OPERATIONS = exports.CALENDLY_OPERATIONS = void 0;
+exports.isCalendlyOperation = isCalendlyOperation;
+/**
+ * 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.
+ */
+exports.CALENDLY_OPERATIONS = [
+    "listEvents",
+    "getEvent",
+    "listInvitees",
+    "cancelEvent",
+    "markNoShow",
+    "undoNoShow",
+    "listEventTypes",
+    "getAvailableTimes",
+    "createSchedulingLink",
+];
+function isCalendlyOperation(value) {
+    return (typeof value === "string" &&
+        exports.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`.
+ */
+exports.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”).",
+});
+/* La zona en la que se leen las fechas de pared de la operación. Sin elegir,
+   la del workspace: el dashboard lo dice debajo del selector y el nodo la lee
+   al ejecutar, como Calendar. */
+const timezone = () => ({
+    name: "timezone",
+    label: "Time zone",
+    type: "timezone",
+    advanced: true,
+    description: "The zone the dates above are read in when they carry no offset. Empty = the workspace's time zone.",
+});
+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}.`,
+});
+exports.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.",
+            },
+            timezone(),
+            {
+                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.",
+            },
+            timezone(),
+        ],
+    },
+    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/connections.js

@@ -83,6 +83,8 @@ exports.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/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/credentials.js

@@ -58,6 +58,26 @@ exports.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

package/dist/dispatch.js

@@ -64,6 +64,8 @@ exports.NODE_DISPATCH = {
     jiraAction: { service: 'jiraActionsService', collection: 'jiraactions', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true, pipelineDispatch: 'excluded', downstreamPayload: 'result' },
     bucketAction: { service: 'bucketActionsService', collection: 'bucketactions', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true, pipelineDispatch: 'excluded', downstreamPayload: 'result' },
     apifyAction: { service: 'apifyActionsService', collection: 'apifyactions', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true, pipelineDispatch: 'excluded', downstreamPayload: 'result' },
+    calendlyAction: { service: 'calendlyActionsService', collection: 'calendlyactions', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true, pipelineDispatch: 'excluded', downstreamPayload: 'result' },
+    airtableAction: { service: 'airtableActionsService', collection: 'airtableactions', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true, pipelineDispatch: 'excluded', downstreamPayload: 'result' },
     slackAction: { service: 'slackActionsService', collection: 'slackactions', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true, pipelineDispatch: 'excluded', downstreamPayload: 'result' },
     googleContactsAction: { service: 'googleContactsActionsService', collection: 'googlecontactsactions', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true, pipelineDispatch: 'excluded', downstreamPayload: 'result' },
     googleAnalyticsAction: { service: 'googleAnalyticsActionsService', collection: 'googleanalyticsactions', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true, pipelineDispatch: 'excluded', downstreamPayload: 'result' },

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

@@ -0,0 +1,90 @@
+/**
+ * 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 declare const AIRTABLE_OPERATIONS: readonly ["listRecords", "getRecord", "createRecord", "updateRecord", "upsertRecord", "deleteRecord", "listBases", "getBaseSchema"];
+export type AirtableOperation = (typeof AIRTABLE_OPERATIONS)[number];
+export declare function isAirtableOperation(value: unknown): value is AirtableOperation;
+/**
+ * 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 declare const AIRTABLE_ITERABLE_OPERATIONS: ReadonlyArray<AirtableOperation>;
+/**
+ * Tipos de parámetro. Los seis primeros son los de Apify. Los nuevos leen el
+ * esquema de la credencial y por eso son de Airtable:
+ *
+ * - `base`: desplegable de bases (`GET /airtable-actions/bases`); el valor es
+ *   el `appXXX`.
+ * - `table`: desplegable de tablas de la base elegida; el valor es el `tblXXX`.
+ * - `view`: desplegable de vistas de la tabla (opcional); el valor es el `viwXXX`.
+ * - `field`: UN campo de la tabla, por nombre.
+ * - `fieldList`: VARIOS campos de la tabla, por nombre; se guarda como array.
+ * - `fields`: el editor de pares campo → valor, con el tipo y las opciones
+ *   de cada campo delante; se guarda como objeto `{ "Nombre": valor }` y las
+ *   cadenas admiten plantilla.
+ *
+ * Todos admiten plantilla como alternativa al desplegable, para cuando el id
+ * viene del payload.
+ */
+export type AirtableParamType = "template" | "textarea" | "json" | "select" | "number" | "booleanSelect" | "base" | "table" | "view" | "field" | "fieldList" | "fields";
+export interface AirtableParamSpec {
+    name: string;
+    label: string;
+    type: AirtableParamType;
+    required?: boolean;
+    description?: string;
+    placeholder?: string;
+    default?: string | number;
+    options?: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>;
+    min?: number;
+    max?: number;
+    advanced?: boolean;
+}
+export interface AirtableOperationSpec {
+    label: string;
+    description: string;
+    apiRoute: string;
+    params: AirtableParamSpec[];
+    /** El campo de la salida que se itera; sólo en las iterables. */
+    iterateField?: string;
+}
+export declare const AIRTABLE_OPERATION_SPECS: Record<AirtableOperation, AirtableOperationSpec>;