@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/solarwinds_service_desk/executors.js

@@ -0,0 +1,160 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { defineProviderExecutors, requireApiKeyCredential, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, providerInputError, providerResponseError, requiredInputString, requiredResponseRecord, runProviderRequest, providerUserAgent, readProviderTextBody, } from "../provider-runtime.js";
+import { solarwindsServiceDeskActions } from "./actions.js";
+const origins = {
+    us: "https://api.samanage.com",
+    eu: "https://apieu.samanage.com",
+    au: "https://apiau.samanage.com",
+};
+const defaultHeaders = {
+    accept: "application/vnd.samanage.v2.1+json",
+    "content-type": "application/json",
+    "user-agent": providerUserAgent,
+};
+function resolveRegion(value) {
+    const region = optionalRawString(value)?.trim() || "us";
+    if (!Object.hasOwn(origins, region))
+        throw providerInputError("region must be us, eu, or au");
+    return region;
+}
+function paginationHeader(headers, name) {
+    const raw = headers.get(name);
+    if (raw === null || raw.trim() === "")
+        return null;
+    const value = Number(raw);
+    return Number.isInteger(value) && value >= 0 ? value : null;
+}
+async function request(baseUrl, route, apiKey, fetcher, method = "GET", body, parentSignal) {
+    return runProviderRequest({ label: "SolarWinds Service Desk", signal: parentSignal }, async (signal) => {
+        const response = await fetcher(`${baseUrl}${route}`, {
+            method,
+            headers: { ...defaultHeaders, "X-Samanage-Authorization": `Bearer ${apiKey}` },
+            signal,
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const text = await readProviderTextBody(response, "solarwinds_service_desk response", undefined, signal);
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            if (response.ok)
+                throw providerResponseError("SolarWinds returned invalid JSON");
+            payload = text;
+        }
+        if (!response.ok) {
+            const error = optionalRecord(payload);
+            const message = optionalRawString(error?.message) ??
+                optionalRawString(error?.error) ??
+                optionalRawString(payload) ??
+                `SolarWinds request failed with HTTP ${response.status}`;
+            throw new ProviderRequestError(response.status, message.replaceAll(apiKey, "[REDACTED]"), undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return { payload, headers: response.headers };
+    });
+}
+const handlers = mapProviderActionHandlers("solarwinds_service_desk", solarwindsServiceDeskActions, (action) => async (values, context) => {
+    const { apiKey, fetcher } = context;
+    const baseUrl = origins[resolveRegion(context.region)];
+    let route = "/incidents.json";
+    let method = "GET";
+    let body;
+    const query = new URLSearchParams();
+    switch (action.name) {
+        case "list_incidents":
+            for (const [key, value] of Object.entries(values))
+                if (value !== undefined)
+                    query.set(key, String(value));
+            break;
+        case "get_incident":
+            route = `/incidents/${values.id}.json`;
+            if (values.layout !== undefined)
+                query.set("layout", String(values.layout));
+            break;
+        case "create_incident":
+            method = "POST";
+            body = { incident: values.incident };
+            break;
+        case "update_incident":
+            route = `/incidents/${values.id}.json`;
+            method = "PUT";
+            body = { incident: values.incident };
+            break;
+        case "delete_incident":
+            route = `/incidents/${values.id}.json`;
+            method = "DELETE";
+            break;
+        case "create_incident_comment":
+            route = `/incidents/${values.id}/comments.json`;
+            method = "POST";
+            body = { comment: { body: values.body, is_private: values.is_private, user_id: values.user_id } };
+            if (values.add_callbacks !== undefined)
+                query.set("add_callbacks", String(values.add_callbacks));
+            break;
+    }
+    const { payload, headers } = await request(baseUrl, `${route}?${query}`, apiKey, fetcher, method, body, context.signal);
+    if (action.name === "list_incidents") {
+        if (!Array.isArray(payload))
+            throw providerResponseError("SolarWinds returned an invalid incident list");
+        return {
+            incidents: payload,
+            page: values.page ?? 1,
+            per_page: paginationHeader(headers, "x-per-page"),
+            total_count: paginationHeader(headers, "x-total-count"),
+            total_pages: paginationHeader(headers, "x-total-pages"),
+            link: headers.get("link"),
+        };
+    }
+    const result = requiredResponseRecord(payload, "SolarWinds response");
+    if (action.name === "delete_incident") {
+        if (!Array.isArray(result.deleted_ids))
+            throw providerResponseError("SolarWinds response is missing deleted_ids");
+        return result;
+    }
+    if (action.name === "create_incident_comment") {
+        requiredResponseRecord(result.comment, "SolarWinds comment");
+        return result;
+    }
+    return { incident: result };
+});
+export const executors = defineProviderExecutors({
+    service: "solarwinds_service_desk",
+    handlers,
+    async createContext(context, fetcher) {
+        const credential = await requireApiKeyCredential(context, "solarwinds_service_desk");
+        return {
+            apiKey: credential.apiKey,
+            fetcher,
+            signal: context.signal,
+            region: credential.values?.region,
+        };
+    },
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const apiKey = requiredInputString(input.apiKey, "API Key");
+        const region = resolveRegion(input.values.region);
+        const { payload } = await request(origins[region], "/api.json", apiKey, fetcher, undefined, undefined, signal);
+        if (!Array.isArray(payload))
+            throw providerResponseError("SolarWinds returned an invalid API directory");
+        return {
+            profile: { displayName: "SolarWinds Service Desk API Token" },
+            grantedScopes: [],
+            metadata: { region, validationEndpoint: "/api.json" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "solarwinds_service_desk",
+    baseUrl: async (context) => origins[resolveRegion((await requireApiKeyCredential(context, "solarwinds_service_desk")).values?.region)],
+    auth: {
+        type: "credential_headers",
+        headers: [{ name: "X-Samanage-Authorization", source: { type: "api_key" }, prefix: "Bearer " }],
+    },
+    allowedOrigins: Object.values(origins),
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries(defaultHeaders))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+});

package/src/providers/spotify/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerInputError, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
 export const spotifyApiBaseUrl = "https://api.spotify.com/v1/";
 export const spotifyActionHandlers = {
     get_current_user_profile(_input, deps) {
@@ -131,9 +131,7 @@ export const spotifyActionHandlers = {
             query: {
                 market: optionalString(input.market),
                 limit: stringifyOptionalInteger(input.limit),
-                seed_artists: joinStringArray(input.seedArtists),
-                seed_tracks: joinStringArray(input.seedTracks),
-                seed_genres: joinStringArray(input.seedGenres),
+                ...buildRecommendationSeedQuery(input),
             },
         });
     },
@@ -761,6 +759,19 @@ function buildPagingQuery(input, extraQuery) {
         ...(extraQuery ?? {}),
     };
 }
+// Spotify takes 1 to 5 seed values in any combination of seed_artists, seed_tracks, and seed_genres.
+function buildRecommendationSeedQuery(input) {
+    const query = {
+        seed_artists: joinStringArray(input.seedArtists),
+        seed_tracks: joinStringArray(input.seedTracks),
+        seed_genres: joinStringArray(input.seedGenres),
+    };
+    const seedCount = [input.seedArtists, input.seedTracks, input.seedGenres].reduce((count, seeds) => count + (Array.isArray(seeds) ? seeds.length : 0), 0);
+    if (seedCount < 1 || seedCount > 5) {
+        throw providerInputError(`get_recommendations needs 1 to 5 seeds across seedArtists, seedTracks, and seedGenres; received ${seedCount}`);
+    }
+    return query;
+}
 function buildPlaybackQuery(input) {
     return {
         market: optionalString(input.market),

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { ApiKeyProviderContext } from "../provider-runtime.ts";
 type StripeActionContext = ApiKeyProviderContext;
@@ -7,4 +9,5 @@ export declare const stripeActionHandlers: ProviderActionHandlers<"stripe", Stri
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/stripe/executors.js

@@ -1,5 +1,6 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
 import { ProviderRequestError, defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, requiredResponseRecord, } from "../provider-runtime.js";
+import { stripeEvent } from "./trigger-on-event.js";
 const service = "stripe";
 const stripeApiBaseUrl = "https://api.stripe.com";
 const stripeApiVersion = "2024-06-20";
@@ -289,3 +290,4 @@ function mapStripeError(status, message) {
     }
     return new ProviderRequestError(502, message, status);
 }
+export const triggers = [stripeEvent];

package/src/providers/stripe/trigger-on-event.d.ts

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

package/src/providers/stripe/trigger-on-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/stripe/trigger-on-event.definition.js

@@ -0,0 +1,43 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "apiVersion",
+            jsonSchema: s.string({ maxLength: 40 }),
+            nullable: false,
+            value: "",
+        },
+        {
+            handle: "events",
+            jsonSchema: s.array(s.string({ maxLength: 120, pattern: "^(\\*|[a-z0-9_]+(?:\\.[a-z0-9_]+)+)$" }), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+            nullable: false,
+        },
+        {
+            handle: "includeConnectedAccounts",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when selected Stripe events happen on the connected account.",
+    displayName: "Account Event",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "stripe.on_event",
+    name: "on_event",
+    outputs: [
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+        { handle: "eventId", jsonSchema: s.string(), nullable: false },
+        { handle: "livemode", jsonSchema: s.boolean(), nullable: false },
+    ],
+    provider: "stripe",
+    type: "integration",
+};

package/src/providers/stripe/trigger-on-event.js

@@ -0,0 +1,212 @@
+import { optionalString } from "../../core/cast.js";
+import { randomUUIDv7 } from "../../core/uuid-v7.js";
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { bytes, verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-event.definition.js";
+const signatureToleranceSeconds = 5 * 60;
+const endpoints = "/v1/webhook_endpoints";
+const formHeaders = { "Content-Type": "application/x-www-form-urlencoded" };
+export const stripeEvent = {
+    initialState: { checkpoint: null, subscription: {} },
+    snapshot,
+    async receive(context) {
+        const signingSecret = subscriptionSecret(context.state);
+        if (signingSecret == null ||
+            !(await validSignature(context.header("stripe-signature"), signingSecret, context.rawBody, context.now))) {
+            return { body: "", contentType: "text/plain", outcome: "respond", status: 404 };
+        }
+        if (context.payload == null || typeof context.payload != "object" || Array.isArray(context.payload)) {
+            return { outcome: "ignored", reason: "Stripe event body is missing." };
+        }
+        const payload = context.payload;
+        const event = payload.type;
+        const eventId = payload.id;
+        if (typeof event != "string" || typeof eventId != "string")
+            return { outcome: "ignored", reason: "Stripe event identity is missing." };
+        const config = resolveConfig(context.config);
+        if (!config.events.includes("*") && !config.events.includes(event))
+            return { outcome: "ignored", reason: "Stripe event is not subscribed." };
+        return {
+            dedupeKey: eventId,
+            outcome: "event",
+            outputs: { body: payload, event, eventId, livemode: payload.livemode === true },
+        };
+    },
+    async reconcile(context) {
+        const state = requireState(context.state);
+        const config = resolveConfig(context.config);
+        let endpointId = subscriptionId(state);
+        let signingSecret = subscriptionSecret(state);
+        let createKey = optionalString(state.subscription.createKey);
+        if (!context.active) {
+            endpointId ??= await findByUrl(context);
+            if (endpointId != null) {
+                const result = await request(context, "endpoint delete", {
+                    endpoint: `${endpoints}/${endpointId}`,
+                    method: "DELETE",
+                });
+                if (result.status != 404)
+                    success(result, "endpoint delete");
+            }
+            await state.saveSubscription({}, later(context.now));
+            return { outcome: "ready" };
+        }
+        if (endpointId == null && createKey == null)
+            endpointId = await findByUrl(context);
+        if (endpointId != null && signingSecret == null) {
+            createKey = randomUUIDv7();
+            await state.saveSubscription({ endpointId, createKey }, context.now);
+            const removed = await request(context, "endpoint delete", {
+                endpoint: `${endpoints}/${endpointId}`,
+                method: "DELETE",
+            });
+            if (removed.status != 404)
+                success(removed, "endpoint delete");
+            endpointId = null;
+        }
+        if (endpointId == null) {
+            createKey ??= context.idempotencyKey;
+            await state.saveSubscription({ createKey }, context.now);
+            const created = await request(context, "endpoint create", {
+                body: createForm(context.endpointUrl, config),
+                endpoint: endpoints,
+                headers: { ...formHeaders, "Idempotency-Key": createKey },
+                method: "POST",
+            });
+            success(created, "endpoint create");
+            const endpoint = createdEndpoint(created.data);
+            endpointId = endpoint.id;
+            signingSecret = endpoint.secret;
+        }
+        await state.saveSubscription({ endpointId, signingSecret }, context.now);
+        const aligned = await request(context, "endpoint update", {
+            body: form([
+                ...config.events.map((event, index) => [`enabled_events[${index}]`, event]),
+                ["disabled", "false"],
+                ["description", "Managed by Open Flow."],
+            ]),
+            endpoint: `${endpoints}/${endpointId}`,
+            headers: formHeaders,
+            method: "POST",
+        });
+        if (aligned.status == 404) {
+            await state.saveSubscription({ createKey: randomUUIDv7() }, context.now);
+            return { outcome: "pending" };
+        }
+        success(aligned, "endpoint update");
+        await state.saveSubscription({ endpointId, signingSecret }, later(context.now));
+        return { outcome: "ready" };
+    },
+};
+function resolveConfig(value) {
+    return {
+        apiVersion: value.apiVersion,
+        events: [...new Set(value.events)],
+        includeConnectedAccounts: value.includeConnectedAccounts,
+    };
+}
+function createForm(url, config) {
+    const fields = [
+        ["url", url],
+        ...config.events.map((event, index) => [`enabled_events[${index}]`, event]),
+        ["description", "Managed by Open Flow."],
+    ];
+    if (config.includeConnectedAccounts)
+        fields.push(["connect", "true"]);
+    if (config.apiVersion.length > 0)
+        fields.push(["api_version", config.apiVersion]);
+    return form(fields);
+}
+function form(fields) {
+    const parameters = new URLSearchParams();
+    for (const [name, value] of fields)
+        parameters.append(name, value);
+    return parameters.toString();
+}
+async function findByUrl(context) {
+    let startingAfter;
+    for (let page = 0; page < 10; page += 1) {
+        const result = await request(context, "endpoint list", {
+            endpoint: endpoints,
+            method: "GET",
+            query: { limit: 100, ...(startingAfter == null ? {} : { starting_after: startingAfter }) },
+        });
+        success(result, "endpoint list");
+        const listing = record(result.data);
+        const values = Array.isArray(listing?.data) ? listing.data : [];
+        for (const value of values) {
+            const endpoint = record(value);
+            if (endpoint?.url === context.endpointUrl && typeof endpoint.id == "string")
+                return endpoint.id;
+        }
+        const last = record(values.at(-1))?.id;
+        if (listing?.has_more !== true || typeof last != "string")
+            return null;
+        startingAfter = last;
+    }
+    return null;
+}
+async function request(context, operation, value) {
+    try {
+        return await context.connector.execute(value, context.signal);
+    }
+    catch (cause) {
+        if (cause instanceof IntegrationConnectionError)
+            throw cause;
+        throw new TransientIntegrationError(`Stripe ${operation} request failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status == 401 || result.status == 403)
+        throw new IntegrationConnectionError(`Stripe ${operation} rejected the Connection.`);
+    if (result.status == 400 || result.status == 404) {
+        const message = record(record(result.data)?.error)?.message;
+        throw new PermanentIntegrationError(`Stripe ${operation} rejected the subscription${typeof message == "string" ? `: ${message}` : "."}`);
+    }
+    throw new TransientIntegrationError(`Stripe ${operation} failed with status ${result.status}.`);
+}
+function createdEndpoint(data) {
+    const value = record(data);
+    if (typeof value?.id != "string" || typeof value.secret != "string" || value.secret.length == 0) {
+        throw new TransientIntegrationError("Stripe endpoint response is missing its ID or signing secret.");
+    }
+    return { id: value.id, secret: value.secret };
+}
+function requireState(value) {
+    if (value == null)
+        throw new PermanentIntegrationError("Stripe Integration state is missing.");
+    return value;
+}
+function subscriptionId(state) {
+    const value = state.subscription.endpointId;
+    return typeof value == "string" && value.length > 0 ? value : null;
+}
+function subscriptionSecret(state) {
+    const value = state?.subscription.signingSecret;
+    return typeof value == "string" && value.length > 0 ? value : null;
+}
+async function validSignature(header, secret, body, now) {
+    if (header == null)
+        return false;
+    const values = header.split(",").map((value) => value.trim().split("=", 2));
+    const timestamp = values.find(([name]) => name == "t")?.[1];
+    if (timestamp == null || !/^\d+$/.test(timestamp))
+        return false;
+    const seconds = Number(timestamp);
+    if (!Number.isSafeInteger(seconds) ||
+        Math.abs(Math.floor(now.getTime() / 1_000) - seconds) > signatureToleranceSeconds)
+        return false;
+    const signatures = values.filter(([name, value]) => name == "v1" && value != null).map(([, value]) => value);
+    const source = [bytes(`${timestamp}.`), body];
+    return (await Promise.all(signatures.map((signature) => verifyHexHmac(secret, source, signature)))).some(Boolean);
+}
+function later(now) {
+    return new Date(now.getTime() + 30 * 24 * 60 * 60 * 1_000);
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/src/providers/supabase/runtime.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { compactObject, nullableString, optionalBoolean, optionalNumber, optionalRawString, optionalRecord, optionalString, requiredRecord, requiredRawString, requiredString, stringArray, } from "../../core/cast.js";
-import { jsonObject, readBoundedResponseBytes } from "../../core/request.js";
+import { jsonObject, readBoundedResponseBytes, storeResponseInTransit } from "../../core/request.js";
 import { providerInputError, ProviderRequestError, providerUserAgent, readTransitFileInput, } from "../provider-runtime.js";
 import { supabaseProviderScopes } from "./scopes.js";
 export const supabaseApiBaseUrl = "https://api.supabase.com/v1";
@@ -425,12 +425,13 @@ async function supabaseDownloadStorageObject(input, context) {
     }
     const name = optionalString(input.fileName) ?? defaultStorageObjectName(objectPath);
     const mimeType = optionalString(response.headers.get("content-type")) ?? "application/octet-stream";
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: context.transitFiles.maxBytes,
+    const file = await storeResponseInTransit(response, context.transitFiles, {
+        name,
+        mimeType,
         fieldName: "Supabase Storage download",
         createError: (message) => new ProviderRequestError(413, message),
+        signal: context.signal,
     });
-    const file = await context.transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
     return {
         fileId: `${bucketId}/${objectPath}`,
         name,

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { ApiKeyProviderContext } from "../provider-runtime.ts";
 type TelegramActionHandler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
@@ -6,4 +8,5 @@ export declare const telegramActionHandlers: ProviderActionHandlers<"telegram",
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/telegram/executors.js

@@ -1,6 +1,7 @@
 import { optionalBoolean, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
 import { assertPublicHttpUrl } from "../../core/request.js";
 import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, ProviderRequestError, requireApiKeyCredential, } from "../provider-runtime.js";
+import { telegramUpdate } from "./trigger-on-update.js";
 const service = "telegram";
 const telegramApiBaseUrl = "https://api.telegram.org";
 const telegramDefaultRequestTimeoutMs = 30_000;
@@ -1165,3 +1166,4 @@ function assertValidTelegramBotToken(botToken) {
         throw new ProviderRequestError(400, "telegram bot token is malformed");
     }
 }
+export const triggers = [telegramUpdate];

package/src/providers/telegram/trigger-on-update.d.ts

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

package/src/providers/telegram/trigger-on-update.definition.d.ts

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

package/src/providers/telegram/trigger-on-update.definition.js

@@ -0,0 +1,78 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const updateTypes = [
+    "*",
+    "message",
+    "edited_message",
+    "channel_post",
+    "edited_channel_post",
+    "business_connection",
+    "business_message",
+    "edited_business_message",
+    "deleted_business_messages",
+    "guest_message",
+    "message_reaction",
+    "message_reaction_count",
+    "inline_query",
+    "chosen_inline_result",
+    "callback_query",
+    "shipping_query",
+    "pre_checkout_query",
+    "purchased_paid_media",
+    "poll",
+    "poll_answer",
+    "my_chat_member",
+    "chat_member",
+    "chat_join_request",
+    "chat_boost",
+    "removed_chat_boost",
+    "managed_bot",
+    "subscription",
+];
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "chatIds",
+            jsonSchema: s.array(s.string({ pattern: "^-?[0-9]{1,20}$" }), { maxItems: 100, uniqueItems: true }),
+            nullable: false,
+            value: [],
+            description: "Only accept updates from these numeric Telegram chat IDs. Empty means every chat.",
+        },
+        {
+            handle: "dropPendingUpdates",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: true,
+            description: "Discard updates queued before the webhook is created or resumed.",
+        },
+        {
+            handle: "updates",
+            jsonSchema: s.array({ enum: updateTypes }, { minItems: 1, uniqueItems: true }),
+            nullable: false,
+            description: "Telegram update types that trigger a Run. Use * for the Telegram default set.",
+        },
+        {
+            handle: "userIds",
+            jsonSchema: s.array(s.string({ pattern: "^[0-9]{1,20}$" }), { maxItems: 100, uniqueItems: true }),
+            nullable: false,
+            value: [],
+            description: "Only accept updates from these numeric Telegram user IDs. Empty means every user.",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when the connected Telegram bot receives a selected update.",
+    displayName: "Bot Update",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 200,
+    },
+    key: "telegram.on_update",
+    name: "on_update",
+    outputs: [
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+    ],
+    provider: "telegram",
+    type: "integration",
+};