@hostwebhook/node-types 1.82.0 → 1.84.0

package/dist/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>;

package/dist/airtable-operations.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIRTABLE_OPERATION_SPECS = exports.AIRTABLE_ITERABLE_OPERATIONS = exports.AIRTABLE_OPERATIONS = void 0;
+exports.isAirtableOperation = isAirtableOperation;
+/**
+ * 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.
+ */
+exports.AIRTABLE_OPERATIONS = [
+    "listRecords",
+    "getRecord",
+    "createRecord",
+    "updateRecord",
+    "upsertRecord",
+    "deleteRecord",
+    "listBases",
+    "getBaseSchema",
+];
+function isAirtableOperation(value) {
+    return (typeof value === "string" &&
+        exports.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`.
+ */
+exports.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.",
+});
+exports.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/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>;