@oomol-lab/open-connector 1.9.1 → 1.9.2

package/src/providers/asana/trigger-on-task-event.js

@@ -0,0 +1,160 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { bytes, verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-task-event.definition.js";
+export const asanaTaskEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const projectId = String(context.config.projectId);
+        const selected = context.config.eventTypes;
+        if (selected.includes("task.field_changed") && typeof context.config.customFieldId != "string")
+            throw new PermanentIntegrationError("Select a custom field for task field changes.");
+        const project = await webhookRequest(context, {
+            endpoint: `/projects/${encodeURIComponent(projectId)}`,
+            method: "GET",
+            query: { opt_fields: "workspace.gid" },
+        });
+        if (!isJsonObject(project.data) ||
+            !isJsonObject(project.data.data) ||
+            !isJsonObject(project.data.data.workspace) ||
+            typeof project.data.data.workspace.gid != "string")
+            throw new TransientIntegrationError("Asana returned no project workspace.");
+        const workspace = project.data.data.workspace.gid;
+        const remove = async (id) => {
+            await webhookRequest(context, { endpoint: `/webhooks/${encodeURIComponent(id)}`, method: "DELETE" });
+        };
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const found = [];
+                const query = {
+                    workspace,
+                    resource: projectId,
+                    limit: 100,
+                    opt_fields: "gid,target,resource.gid",
+                };
+                const seen = new Set();
+                for (let page = 0; page < 100; page++) {
+                    const response = await webhookRequest(context, { endpoint: "/webhooks", method: "GET", query });
+                    if (!isJsonObject(response.data) || !Array.isArray(response.data.data))
+                        throw new TransientIntegrationError("Asana returned an invalid webhook list.");
+                    for (const item of response.data.data) {
+                        if (!isJsonObject(item) || typeof item.target != "string" || typeof item.gid != "string")
+                            throw new TransientIntegrationError("Asana returned an invalid webhook.");
+                        if (item.target != context.endpointUrl)
+                            continue;
+                        if (!isJsonObject(item.resource) || item.resource.gid != projectId)
+                            throw new PermanentIntegrationError("Asana webhook project does not match.");
+                        found.push({
+                            id: item.gid,
+                            secret: context.state?.subscription.hookId == item.gid && typeof context.state.subscription.secret == "string"
+                                ? context.state.subscription.secret
+                                : "",
+                        });
+                    }
+                    const next = response.data.next_page;
+                    if (next == null)
+                        break;
+                    if (!isJsonObject(next) || typeof next.offset != "string" || seen.has(next.offset))
+                        throw new TransientIntegrationError("Asana webhook pagination did not advance.");
+                    seen.add(next.offset);
+                    query.offset = next.offset;
+                    if (page == 99)
+                        throw new PermanentIntegrationError("The Asana webhook list exceeds 10000 entries.");
+                }
+                if (found.length == 1 && !found[0].secret && context.active) {
+                    // Recover the unique owned orphan by deleting it before recreating its unreadable secret.
+                    await remove(found[0].id);
+                    await context.state.saveSubscription({}, context.now);
+                    return [];
+                }
+                return found;
+            },
+            async create() {
+                const response = await webhookRequest(context, {
+                    endpoint: "/webhooks",
+                    method: "POST",
+                    body: {
+                        data: {
+                            resource: projectId,
+                            target: context.endpointUrl,
+                            filters: [
+                                { resource_type: "task", action: "added" },
+                                { resource_type: "task", action: "changed", fields: ["completed", "custom_fields"] },
+                            ],
+                        },
+                    },
+                });
+                if (!isJsonObject(response.data) ||
+                    !isJsonObject(response.data.data) ||
+                    typeof response.data.data.gid != "string" ||
+                    typeof response.data["X-Hook-Secret"] != "string" ||
+                    !response.data["X-Hook-Secret"])
+                    throw new TransientIntegrationError("Asana webhook creation returned no identity or signing secret.");
+                return { id: response.data.data.gid, secret: response.data["X-Hook-Secret"] };
+            },
+            remove,
+        });
+    },
+    async receive(context) {
+        const secret = context.state?.subscription.secret;
+        if (typeof secret != "string")
+            return { outcome: "respond", status: 503, body: "", contentType: "text/plain" };
+        if (!(await verifyHexHmac(secret, [context.rawBody], context.header("x-hook-signature"))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) || !Array.isArray(payload.events))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        const events = [];
+        const identities = [];
+        const selected = context.config.eventTypes;
+        for (const item of payload.events) {
+            if (!isJsonObject(item) || !isJsonObject(item.resource) || item.resource.resource_type != "task")
+                continue;
+            if (typeof item.resource.gid != "string" || typeof item.created_at != "string")
+                return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+            let event;
+            if (item.action == "added" && isJsonObject(item.parent) && item.parent.gid == context.config.projectId)
+                event = "task.added";
+            if (item.action == "changed" && isJsonObject(item.change)) {
+                if (item.change.field == "completed")
+                    event = "task.completed";
+                if (item.change.field == "custom_fields" &&
+                    isJsonObject(item.change.new_value) &&
+                    item.change.new_value.gid == context.config.customFieldId)
+                    event = "task.field_changed";
+            }
+            if (!event || !selected.includes(event))
+                continue;
+            const response = await context.connector.execute({
+                endpoint: `/tasks/${encodeURIComponent(item.resource.gid)}`,
+                method: "GET",
+                query: { opt_fields: "gid,name,completed,memberships.project.gid,custom_fields" },
+            }, context.signal);
+            if (response.status == 404)
+                continue;
+            if (response.status < 200 || response.status >= 300)
+                throw new TransientIntegrationError(`Asana task lookup failed (HTTP ${response.status}).`);
+            if (!isJsonObject(response.data) ||
+                !isJsonObject(response.data.data) ||
+                !Array.isArray(response.data.data.memberships))
+                throw new TransientIntegrationError("Asana returned invalid task details.");
+            const task = response.data.data;
+            if (!task.memberships.some((member) => isJsonObject(member) && isJsonObject(member.project) && member.project.gid == context.config.projectId))
+                continue;
+            if (event == "task.completed" && task.completed !== true)
+                continue;
+            events.push({ event, task, change: item });
+            identities.push(JSON.stringify(item));
+        }
+        if (!events.length)
+            return { outcome: "ignored", reason: "No matching project task changes." };
+        const digest = await crypto.subtle.digest("SHA-256", bytes(JSON.stringify(identities.sort())));
+        return {
+            outcome: "event",
+            dedupeKey: Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join(""),
+            outputs: { projectId: context.config.projectId, events },
+        };
+    },
+};

package/src/providers/calendly/executors.d.ts

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/calendly/executors.js

@@ -1,5 +1,6 @@
 import { defineBearerProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { calendlyActionHandlers, calendlyApiOrigin, validateCalendlyCredential } from "./runtime.js";
+import { calendlyBookingEvent } from "./trigger-on-booking-event.js";
 const service = "calendly";
 export const executors = defineBearerProviderExecutors(service, calendlyActionHandlers);
 export const proxy = defineProviderProxy({
@@ -15,3 +16,4 @@ export const credentialValidators = {
         return validateCalendlyCredential(input.accessToken, fetcher, signal);
     },
 };
+export const triggers = [calendlyBookingEvent];

package/src/providers/calendly/trigger-on-booking-event.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const calendlyBookingEvent: IntegrationDefinition;

package/src/providers/calendly/trigger-on-booking-event.definition.d.ts

@@ -0,0 +1,5 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const events: readonly ["invitee.created", "invitee.canceled"];
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/calendly/trigger-on-booking-event.definition.js

@@ -0,0 +1,42 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const events = ["invitee.created", "invitee.canceled"];
+export const snapshot = {
+    key: "calendly.on_booking_event",
+    provider: "calendly",
+    name: "on_booking_event",
+    displayName: "Booking Created or Canceled",
+    description: "Receives bookings and cancellations, preserving reschedule links. Requires a Personal Access Token connection.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "scope",
+            jsonSchema: { type: "string", enum: ["user", "organization"], title: "Scope" },
+            nullable: false,
+            value: "user",
+        },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", enum: events },
+                minItems: 1,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: events,
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string", enum: events }, nullable: false },
+        { handle: "inviteeUri", jsonSchema: s.string(), nullable: false },
+        { handle: "createdAt", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/calendly/trigger-on-booking-event.js

@@ -0,0 +1,144 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { bytes, verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-booking-event.definition.js";
+function webhookId(uri) {
+    if (typeof uri != "string" || !uri.startsWith("https://api.calendly.com/webhook_subscriptions/"))
+        throw new TransientIntegrationError("Calendly returned an invalid subscription URI.");
+    const id = uri.slice("https://api.calendly.com/webhook_subscriptions/".length);
+    if (!id || id.includes("/") || id.includes("?") || id.includes("#"))
+        throw new TransientIntegrationError("Calendly returned an invalid subscription identity.");
+    return id;
+}
+export const calendlyBookingEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        // OAuth subscriptions use the application signing key; signing_key cannot override it.
+        if (context.connector.authType != "api_key")
+            throw new PermanentIntegrationError("Calendly Triggers require a Personal Access Token connection. OAuth application signing keys are not configured by this deployment.");
+        const current = await webhookRequest(context, { endpoint: "/users/me", method: "GET" });
+        if (!isJsonObject(current.data) ||
+            !isJsonObject(current.data.resource) ||
+            typeof current.data.resource.uri != "string" ||
+            typeof current.data.resource.current_organization != "string")
+            throw new TransientIntegrationError("Calendly returned an invalid current user.");
+        const organization = current.data.resource.current_organization;
+        const user = current.data.resource.uri;
+        const scope = String(context.config.scope);
+        const query = { organization, scope, count: 100 };
+        if (scope == "user")
+            query.user = user;
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const found = [];
+                const seen = new Set();
+                for (let page = 0; page < 100; page++) {
+                    const result = await webhookRequest(context, {
+                        endpoint: "/webhook_subscriptions",
+                        method: "GET",
+                        query,
+                    });
+                    if (!isJsonObject(result.data) ||
+                        !Array.isArray(result.data.collection) ||
+                        !isJsonObject(result.data.pagination))
+                        throw new TransientIntegrationError("Calendly returned an invalid webhook page.");
+                    for (const item of result.data.collection) {
+                        if (!isJsonObject(item) || typeof item.callback_url != "string")
+                            throw new TransientIntegrationError("Calendly returned an invalid webhook.");
+                        if (item.callback_url != context.endpointUrl)
+                            continue;
+                        if (item.organization != organization || item.scope != scope || (scope == "user" && item.user != user))
+                            throw new PermanentIntegrationError("Calendly webhook scope differs from this subscription.");
+                        if (context.active && item.state != "active")
+                            throw new PermanentIntegrationError("Calendly disabled this webhook. Restore it or remove the owned webhook before retrying.");
+                        if (context.active &&
+                            (!Array.isArray(item.events) ||
+                                item.events.length != context.config.eventTypes.length ||
+                                !context.config.eventTypes.every((event) => item.events.includes(event))))
+                            throw new PermanentIntegrationError("Calendly webhook events differ from this subscription. Remove the owned webhook before retrying.");
+                        found.push({ id: webhookId(item.uri), secret: context.callbackSecret });
+                    }
+                    const next = result.data.pagination.next_page_token;
+                    if (next == null)
+                        return found;
+                    if (typeof next != "string" || !next || seen.has(next))
+                        throw new TransientIntegrationError("Calendly webhook pagination did not advance.");
+                    seen.add(next);
+                    query.page_token = next;
+                }
+                throw new PermanentIntegrationError("The Calendly webhook list exceeds 10000 entries.");
+            },
+            async create() {
+                const body = {
+                    url: context.endpointUrl,
+                    events: context.config.eventTypes,
+                    organization,
+                    scope,
+                    signing_key: context.callbackSecret,
+                };
+                if (scope == "user")
+                    body.user = user;
+                const result = await webhookRequest(context, {
+                    endpoint: "/webhook_subscriptions",
+                    method: "POST",
+                    body,
+                });
+                if (!isJsonObject(result.data) || !isJsonObject(result.data.resource))
+                    throw new TransientIntegrationError("Calendly webhook creation returned no resource.");
+                return { id: webhookId(result.data.resource.uri), secret: context.callbackSecret };
+            },
+            async remove(id) {
+                await webhookRequest(context, {
+                    endpoint: `/webhook_subscriptions/${encodeURIComponent(id)}`,
+                    method: "DELETE",
+                });
+            },
+        });
+    },
+    async receive(context) {
+        const parts = context
+            .header("calendly-webhook-signature")
+            ?.split(",")
+            .map((part) => part.trim()) ?? [];
+        const timestamps = parts.filter((part) => part.startsWith("t="));
+        const timestamp = timestamps[0]?.slice(2);
+        let valid = false;
+        if (timestamps.length == 1 &&
+            timestamp &&
+            Number.isInteger(Number(timestamp)) &&
+            Math.abs(context.now.getTime() / 1000 - Number(timestamp)) <= 180) {
+            for (const part of parts) {
+                if (part.startsWith("v1=") &&
+                    (await verifyHexHmac(context.callbackSecret, [bytes(`${timestamp}.`), context.rawBody], part.slice(3)))) {
+                    valid = true;
+                    break;
+                }
+            }
+        }
+        if (!valid)
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const body = context.payload;
+        if (!isJsonObject(body) ||
+            typeof body.event != "string" ||
+            !context.config.eventTypes.includes(body.event))
+            return { outcome: "ignored", reason: "Calendly event does not match." };
+        if (!isJsonObject(body.payload) ||
+            typeof body.payload.uri != "string" ||
+            !body.payload.uri ||
+            typeof body.created_at != "string" ||
+            !body.created_at)
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: JSON.stringify([body.event, body.payload.uri, body.created_at]),
+            outputs: {
+                event: body.event,
+                inviteeUri: body.payload.uri,
+                createdAt: body.created_at,
+                body: body.payload,
+            },
+        };
+    },
+};

package/src/providers/clickup/executors.d.ts

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/clickup/executors.js

@@ -1,5 +1,6 @@
 import { defineProviderExecutors, defineProviderProxy, ProviderRequestError } from "../provider-runtime.js";
 import { clickupActionHandlers, clickupApiOrigin, validateClickupCredential } from "./runtime.js";
+import { clickupTaskEvent } from "./trigger-on-task-event.js";
 const service = "clickup";
 export const executors = defineProviderExecutors({
     service,
@@ -52,3 +53,4 @@ export const credentialValidators = {
         return validateClickupCredential(input.accessToken, "oauth2", fetcher, signal);
     },
 };
+export const triggers = [clickupTaskEvent];

package/src/providers/clickup/trigger-on-task-event.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const clickupTaskEvent: IntegrationDefinition;

package/src/providers/clickup/trigger-on-task-event.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/clickup/trigger-on-task-event.definition.js

@@ -0,0 +1,41 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const events = ["taskCreated", "taskStatusUpdated", "taskCommentPosted"];
+export const snapshot = {
+    key: "clickup.on_task_event",
+    provider: "clickup",
+    name: "on_task_event",
+    displayName: "Task Event",
+    description: "Receives task creation, status changes, and new comments in a ClickUp Workspace or List.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "workspaceId",
+            jsonSchema: { type: "string", pattern: "^[0-9]+$", title: "Workspace ID" },
+            nullable: false,
+        },
+        { handle: "listId", jsonSchema: { type: "string", pattern: "^[0-9]+$", title: "List ID" }, nullable: true },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", enum: events },
+                minItems: 1,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: events,
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string", enum: events }, nullable: false },
+        { handle: "taskId", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/clickup/trigger-on-task-event.js

@@ -0,0 +1,94 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-task-event.definition.js";
+function webhook(value) {
+    if (!isJsonObject(value) ||
+        typeof value.id != "string" ||
+        !value.id ||
+        typeof value.secret != "string" ||
+        !value.secret)
+        throw new TransientIntegrationError("ClickUp returned an invalid webhook identity or secret.");
+    return { id: value.id, secret: value.secret };
+}
+export const clickupTaskEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const endpoint = `/team/${encodeURIComponent(String(context.config.workspaceId))}/webhook`;
+        const location = context.config.listId == null ? {} : { list_id: Number(context.config.listId) };
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const result = await webhookRequest(context, { endpoint, method: "GET" });
+                if (!isJsonObject(result.data) || !Array.isArray(result.data.webhooks))
+                    throw new TransientIntegrationError("ClickUp returned an invalid webhook list.");
+                return result.data.webhooks
+                    .filter((item) => {
+                    if (!isJsonObject(item) || typeof item.endpoint != "string")
+                        throw new TransientIntegrationError("ClickUp returned an invalid webhook.");
+                    if (item.endpoint !== context.endpointUrl)
+                        return false;
+                    if (context.active && String(item.list_id ?? "") !== String(context.config.listId ?? ""))
+                        throw new PermanentIntegrationError("The ClickUp webhook no longer matches the configured List. Remove the subscription before recreating it.");
+                    return true;
+                })
+                    .map(webhook);
+            },
+            async create() {
+                const result = await webhookRequest(context, {
+                    endpoint,
+                    method: "POST",
+                    body: { endpoint: context.endpointUrl, events: context.config.eventTypes, ...location },
+                });
+                if (!isJsonObject(result.data) || !isJsonObject(result.data.webhook))
+                    throw new TransientIntegrationError("ClickUp webhook creation returned no webhook.");
+                return webhook(result.data.webhook);
+            },
+            async align(id) {
+                await webhookRequest(context, {
+                    endpoint: `/webhook/${encodeURIComponent(id)}`,
+                    method: "PUT",
+                    body: {
+                        endpoint: context.endpointUrl,
+                        events: context.config.eventTypes,
+                        status: "active",
+                    },
+                });
+            },
+            async remove(id) {
+                await webhookRequest(context, {
+                    endpoint: `/webhook/${encodeURIComponent(id)}`,
+                    method: "DELETE",
+                });
+            },
+        });
+    },
+    async receive(context) {
+        const secret = context.state?.subscription.secret;
+        if (typeof secret != "string")
+            return { outcome: "respond", status: 503, body: "", contentType: "text/plain" };
+        if (!(await verifyHexHmac(secret, [context.rawBody], context.header("x-signature"))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const body = context.payload;
+        if (!isJsonObject(body) ||
+            body.webhook_id != context.state?.subscription.hookId ||
+            typeof body.event != "string" ||
+            !context.config.eventTypes.includes(body.event))
+            return { outcome: "ignored", reason: "ClickUp subscription or event does not match." };
+        if (typeof body.task_id != "string" ||
+            !body.task_id ||
+            (body.history_items != null &&
+                (!Array.isArray(body.history_items) ||
+                    body.history_items.some((item) => !isJsonObject(item) || typeof item.id != "string" || !item.id))))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        const historyIds = body.history_items?.map((item) => item.id).sort() ?? [];
+        if (historyIds.length == 0 && body.event != "taskCreated")
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: JSON.stringify([body.webhook_id, body.event, historyIds.length ? historyIds : body.task_id]),
+            outputs: { event: body.event, taskId: body.task_id, body },
+        };
+    },
+};

package/src/providers/cloro/actions.d.ts

@@ -0,0 +1,12 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export interface CloroEndpoint {
+    action: ActionDefinition;
+    path: string;
+    method: "GET" | "POST" | "DELETE";
+    timeoutMs?: number;
+    arrayField?: string;
+}
+declare const endpoints: CloroEndpoint[];
+export declare const cloroActions: ActionDefinition[];
+export declare const cloroEndpointByName: Map<string, (typeof endpoints)[number]>;
+export {};