@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/woocommerce/trigger-on-store-event.definition.js

@@ -0,0 +1,55 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const topics = [
+    "coupon.created",
+    "coupon.updated",
+    "coupon.deleted",
+    "coupon.restored",
+    "customer.created",
+    "customer.updated",
+    "customer.deleted",
+    "order.created",
+    "order.updated",
+    "order.deleted",
+    "order.restored",
+    "product.created",
+    "product.updated",
+    "product.deleted",
+    "product.restored",
+    "product.published",
+];
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.stringEnum(topics), { maxItems: 16, minItems: 1, uniqueItems: true }),
+            nullable: false,
+        },
+        {
+            handle: "webhookName",
+            jsonSchema: s.string({ maxLength: 120, minLength: 1 }),
+            nullable: false,
+            value: "OOMOL Trigger",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when selected WooCommerce store events occur.",
+    displayName: "Store Event",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "woocommerce.on_store_event",
+    name: "on_store_event",
+    outputs: [
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+        { handle: "resource", jsonSchema: s.string(), nullable: false },
+        { handle: "source", jsonSchema: s.string(), nullable: false },
+        { handle: "topic", jsonSchema: s.string(), nullable: false },
+        { handle: "webhookId", jsonSchema: s.string(), nullable: false },
+    ],
+    provider: "woocommerce",
+    type: "integration",
+};

package/src/providers/woocommerce/trigger-on-store-event.js

@@ -0,0 +1,179 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { verifyBase64Hmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-store-event.definition.js";
+export const wooCommerceStoreEvent = {
+    initialState: { checkpoint: null, subscription: {} },
+    snapshot,
+    async receive(context) {
+        if (!(await verifyBase64Hmac(context.callbackSecret, [context.rawBody], context.header("x-wc-webhook-signature")))) {
+            return { body: "", contentType: "text/plain", outcome: "respond", status: 404 };
+        }
+        const topic = context.header("x-wc-webhook-topic")?.trim();
+        if (!topic)
+            return { outcome: "ignored", reason: "WooCommerce topic header is missing." };
+        if (!resolveConfig(context.config).events.includes(topic))
+            return { outcome: "ignored", reason: "WooCommerce topic is not subscribed." };
+        const deliveryId = context.header("x-wc-webhook-delivery-id") ?? "";
+        return {
+            dedupeKey: deliveryId.length == 0 ? undefined : deliveryId,
+            outcome: "event",
+            outputs: {
+                body: context.payload,
+                deliveryId,
+                event: context.header("x-wc-webhook-event") ?? "",
+                resource: context.header("x-wc-webhook-resource") ?? "",
+                source: context.header("x-wc-webhook-source") ?? "",
+                topic,
+                webhookId: context.header("x-wc-webhook-id") ?? "",
+            },
+        };
+    },
+    async reconcile(context) {
+        const state = requireState(context.state);
+        const config = resolveConfig(context.config);
+        const listed = await list(context);
+        if (!context.active) {
+            for (const value of listed)
+                await remove(context, value.id);
+            await state.saveSubscription({}, later(context.now));
+            return { outcome: "ready" };
+        }
+        const adopted = new Map();
+        for (const value of listed)
+            if (config.events.includes(value.topic) && !adopted.has(value.topic))
+                adopted.set(value.topic, value.id);
+        const kept = new Set(adopted.values());
+        for (const value of listed)
+            if (!kept.has(value.id))
+                await remove(context, value.id);
+        const ids = [];
+        for (const topic of config.events) {
+            const existing = adopted.get(topic);
+            ids.push(existing == null ? await create(context, config, topic) : await align(context, existing, topic));
+        }
+        await state.saveSubscription({ webhookIds: ids }, later(context.now));
+        return { outcome: "ready" };
+    },
+};
+function resolveConfig(value) {
+    return {
+        events: [...new Set(value.events)],
+        webhookName: value.webhookName,
+    };
+}
+async function create(context, config, topic) {
+    const result = await request(context, `webhook create (${topic})`, {
+        body: {
+            delivery_url: context.endpointUrl,
+            name: `${config.webhookName} - ${topic}`,
+            secret: context.callbackSecret,
+            topic,
+        },
+        endpoint: "/webhooks",
+        method: "POST",
+    });
+    success(result, `webhook create (${topic})`);
+    return readId(result.data);
+}
+async function align(context, webhookId, topic) {
+    const result = await request(context, `webhook update (${topic})`, {
+        body: {
+            delivery_url: context.endpointUrl,
+            secret: context.callbackSecret,
+            status: "active",
+            topic,
+        },
+        endpoint: `/webhooks/${webhookId}`,
+        method: "PUT",
+    });
+    if (invalidId(result))
+        return create(context, resolveConfig(context.config), topic);
+    success(result, `webhook update (${topic})`);
+    return webhookId;
+}
+async function list(context) {
+    const matches = [];
+    for (let page = 1; page <= 10; page += 1) {
+        const result = await request(context, "webhook list", {
+            endpoint: "/webhooks",
+            method: "GET",
+            query: { context: "view", page, per_page: 100, status: "all" },
+        });
+        success(result, "webhook list");
+        const hooks = Array.isArray(result.data) ? result.data : [];
+        for (const hook of hooks) {
+            const value = record(hook);
+            if (value?.delivery_url !== context.endpointUrl || typeof value.topic != "string")
+                continue;
+            const webhookId = normalizeId(value.id);
+            if (webhookId != null)
+                matches.push({ id: webhookId, topic: value.topic });
+        }
+        if (hooks.length < 100)
+            return matches;
+    }
+    throw new TransientIntegrationError("WooCommerce webhook list did not finish within ten pages.");
+}
+async function remove(context, webhookId) {
+    const result = await request(context, "webhook delete", {
+        endpoint: `/webhooks/${webhookId}`,
+        method: "DELETE",
+        query: { force: "true" },
+    });
+    if (result.status != 404)
+        success(result, "webhook delete");
+}
+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(`WooCommerce ${operation} request failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    const code = errorCode(result.data);
+    if (result.status == 401 || result.status == 403)
+        throw new IntegrationConnectionError(`WooCommerce ${operation} rejected the Connection.`);
+    if (result.status == 404 ||
+        (result.status == 400 && (code.endsWith("_invalid_topic") || code.endsWith("_invalid_delivery_url"))) ||
+        (result.status == 501 && code == "woocommerce_rest_trash_not_supported")) {
+        throw new PermanentIntegrationError(`WooCommerce ${operation} rejected the subscription.`);
+    }
+    throw new TransientIntegrationError(`WooCommerce ${operation} failed with status ${result.status}.`);
+}
+function invalidId(result) {
+    return result.status == 400 && errorCode(result.data) == "woocommerce_rest_webhook_invalid_id";
+}
+function errorCode(data) {
+    const value = record(data)?.code;
+    return typeof value == "string" ? value : "";
+}
+function readId(data) {
+    const value = normalizeId(record(data)?.id);
+    if (value == null)
+        throw new TransientIntegrationError("WooCommerce webhook response is missing its ID.");
+    return value;
+}
+function normalizeId(value) {
+    if (typeof value == "string" && value.length > 0)
+        return value;
+    return typeof value == "number" && Number.isFinite(value) ? String(value) : null;
+}
+function requireState(value) {
+    if (value == null)
+        throw new PermanentIntegrationError("WooCommerce Integration state is missing.");
+    return value;
+}
+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/xydc_mcp/executors.js

@@ -38,7 +38,7 @@ export const proxy = defineProviderProxy({
     },
     timeoutMs: generationTimeoutMs,
     skipDnsValidation: true,
-    redirect: "error",
+    redirect: "manual",
     customizeRequest({ headers }) {
         headers.set("accept", "application/json, text/event-stream");
         headers.set("content-type", "application/json");
@@ -61,7 +61,7 @@ async function withClient(context, run) {
         transport: "streamable_http",
         fetcher: context.fetcher,
         headers: { authorization: `Bearer ${context.apiKey}`, "user-agent": providerUserAgent },
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError,
     }, run);

package/src/providers/youtube/executors.js

@@ -1,4 +1,4 @@
-import { googleJsonRequest } from "../google-runtime.js";
+import { googleJsonRequest } from "../googledrive/runtime-request.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, providerProxyEndpointPrefixes, } from "../provider-runtime.js";
 import { youtubeActionHandlers } from "./runtime.js";
 const service = "youtube";

package/src/providers/youtube/runtime.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { compactObject, optionalBoolean, optionalInteger, optionalString, rawStringOrNull } from "../../core/cast.js";
 import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
-import { googleJsonRequest, googleRequest } from "../google-runtime.js";
+import { googleJsonRequest, googleRequest } from "../googledrive/runtime-request.js";
 import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
 const youtubeApiBaseUrl = "https://www.googleapis.com/youtube/v3";
 const youtubeUploadApiBaseUrl = "https://www.googleapis.com/upload/youtube/v3";

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

@@ -1,4 +1,7 @@
 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";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];

package/src/providers/zendesk/executors.js

@@ -1,5 +1,6 @@
 import { basicAuthorizationHeader, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, providerFetch, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireApiKeyCredential, requireOAuthCredential, toProviderProxyError, } from "../provider-runtime.js";
 import { validateZendeskCredential, zendeskActionHandlers } from "./runtime.js";
+import { zendeskEvent } from "./trigger-on-event.js";
 const service = "zendesk";
 export const executors = defineProviderExecutors({
     service,
@@ -128,3 +129,4 @@ function normalizeZendeskSubdomain(raw) {
     }
     return subdomain;
 }
+export const triggers = [zendeskEvent];

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

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

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

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

package/src/providers/zendesk/trigger-on-event.definition.js

@@ -0,0 +1,101 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const events = [
+    "zen:event-type:ticket.agent_assignment_changed",
+    "zen:event-type:ticket.attachment_linked_to_comment",
+    "zen:event-type:ticket.attachment_redacted_from_comment",
+    "zen:event-type:ticket.brand_changed",
+    "zen:event-type:ticket.comment_added",
+    "zen:event-type:ticket.comment_made_private",
+    "zen:event-type:ticket.comment_redacted",
+    "zen:event-type:ticket.created",
+    "zen:event-type:ticket.csat_received",
+    "zen:event-type:ticket.csat_requested",
+    "zen:event-type:ticket.custom_field_changed",
+    "zen:event-type:ticket.custom_status_changed",
+    "zen:event-type:ticket.description_changed",
+    "zen:event-type:ticket.email_ccs_changed",
+    "zen:event-type:ticket.external_id_changed",
+    "zen:event-type:ticket.followers_changed",
+    "zen:event-type:ticket.form_changed",
+    "zen:event-type:ticket.group_assignment_changed",
+    "zen:event-type:ticket.marked_as_spam",
+    "zen:event-type:ticket.merged",
+    "zen:event-type:ticket.next_sla_breach_changed",
+    "zen:event-type:ticket.ola_policy_changed",
+    "zen:event-type:ticket.organization_changed",
+    "zen:event-type:ticket.permanently_deleted",
+    "zen:event-type:ticket.priority_changed",
+    "zen:event-type:ticket.problem_link_changed",
+    "zen:event-type:ticket.requester_changed",
+    "zen:event-type:ticket.schedule_changed",
+    "zen:event-type:ticket.sla_policy_changed",
+    "zen:event-type:ticket.soft_deleted",
+    "zen:event-type:ticket.status_changed",
+    "zen:event-type:ticket.subject_changed",
+    "zen:event-type:ticket.submitter_changed",
+    "zen:event-type:ticket.tags_changed",
+    "zen:event-type:ticket.task_due_at_changed",
+    "zen:event-type:ticket.type_changed",
+    "zen:event-type:ticket.undeleted",
+    "zen:event-type:organization.created",
+    "zen:event-type:organization.custom_field_changed",
+    "zen:event-type:organization.deleted",
+    "zen:event-type:organization.external_id_changed",
+    "zen:event-type:organization.name_changed",
+    "zen:event-type:organization.tags_changed",
+    "zen:event-type:user.active_changed",
+    "zen:event-type:user.alias_changed",
+    "zen:event-type:user.created",
+    "zen:event-type:user.custom_field_changed",
+    "zen:event-type:user.custom_role_changed",
+    "zen:event-type:user.default_group_changed",
+    "zen:event-type:user.deleted",
+    "zen:event-type:user.details_changed",
+    "zen:event-type:user.external_id_changed",
+    "zen:event-type:user.group_membership_created",
+    "zen:event-type:user.group_membership_deleted",
+    "zen:event-type:user.identity_changed",
+    "zen:event-type:user.identity_created",
+    "zen:event-type:user.identity_deleted",
+    "zen:event-type:user.last_login_changed",
+    "zen:event-type:user.merged",
+    "zen:event-type:user.name_changed",
+    "zen:event-type:user.notes_changed",
+    "zen:event-type:user.only_private_comments_changed",
+    "zen:event-type:user.organization_membership_created",
+    "zen:event-type:user.organization_membership_deleted",
+    "zen:event-type:user.password_changed",
+    "zen:event-type:user.photo_changed",
+    "zen:event-type:user.role_changed",
+    "zen:event-type:user.suspended_changed",
+    "zen:event-type:user.tags_changed",
+    "zen:event-type:user.time_zone_changed",
+];
+export const endpoint = "/api/v2/webhooks";
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.stringEnum(events), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when one of the selected Zendesk account events occurs.",
+    displayName: "Event Subscription",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "zendesk.on_event",
+    name: "on_event",
+    outputs: [
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+        { handle: "subject", jsonSchema: s.string(), nullable: false },
+    ],
+    provider: "zendesk",
+    type: "integration",
+};

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

@@ -0,0 +1,188 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { bytes, verifyBase64Hmac } from "../../triggers/signature.js";
+import { snapshot, endpoint } from "./trigger-on-event.definition.js";
+const signatureToleranceMs = 5 * 60 * 1_000;
+export const zendeskEvent = {
+    initialState: { checkpoint: null, subscription: {} },
+    snapshot,
+    async receive(context) {
+        const signingSecret = subscriptionSecret(context.state);
+        const timestamp = context.header("x-zendesk-webhook-signature-timestamp");
+        const signedAt = timestamp == null ? Number.NaN : Date.parse(timestamp);
+        if (signingSecret == null ||
+            timestamp == null ||
+            !Number.isFinite(signedAt) ||
+            Math.abs(context.now.getTime() - signedAt) > signatureToleranceMs ||
+            !(await verifyBase64Hmac(signingSecret, [bytes(timestamp), context.rawBody], context.header("x-zendesk-webhook-signature")))) {
+            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: "Zendesk event body is missing." };
+        }
+        const payload = context.payload;
+        const event = payload.type;
+        if (typeof event != "string" || event.length == 0)
+            return { outcome: "ignored", reason: "Zendesk event type is missing." };
+        if (!context.config.events.includes(event))
+            return { outcome: "ignored", reason: "Zendesk event is not subscribed." };
+        const deliveryId = typeof payload.id == "string" ? payload.id : "";
+        const subject = payload.subject;
+        return {
+            dedupeKey: deliveryId.length == 0 ? undefined : deliveryId,
+            outcome: "event",
+            outputs: {
+                body: payload,
+                deliveryId,
+                event,
+                ...(typeof subject == "string" ? { subject } : {}),
+            },
+        };
+    },
+    async reconcile(context) {
+        const state = requireState(context.state);
+        const listed = await findByEndpoint(context);
+        const known = subscriptionId(state);
+        if (!context.active) {
+            for (const webhookId of known == null ? listed : [...new Set([known, ...listed])])
+                await remove(context, webhookId);
+            await state.saveSubscription({}, later(context.now));
+            return { outcome: "ready" };
+        }
+        let webhookId = known ?? listed[0];
+        if (webhookId == null) {
+            const created = await request(context, "webhook create", {
+                body: desired(context),
+                endpoint,
+                method: "POST",
+            });
+            success(created, "webhook create");
+            webhookId = readId(record(created.data)?.webhook);
+        }
+        else {
+            const aligned = await request(context, "webhook update", {
+                body: desired(context),
+                endpoint: `${endpoint}/${webhookId}`,
+                method: "PUT",
+            });
+            if (aligned.status == 404) {
+                await state.saveSubscription({}, context.now);
+                return { outcome: "pending" };
+            }
+            success(aligned, "webhook update");
+        }
+        await state.saveSubscription({ ...state.subscription, webhookId }, context.now);
+        for (const duplicate of listed.filter((value) => value != webhookId))
+            await remove(context, duplicate);
+        await state.saveSubscription({ signingSecret: await readSigningSecret(context, webhookId), webhookId }, later(context.now));
+        return { outcome: "ready" };
+    },
+};
+function desired(context) {
+    return {
+        webhook: {
+            description: "Managed by Open Flow. Do not edit.",
+            endpoint: context.endpointUrl,
+            http_method: "POST",
+            name: name(context.endpointUrl),
+            request_format: "json",
+            status: "active",
+            subscriptions: [...new Set(context.config.events)],
+        },
+    };
+}
+async function findByEndpoint(context) {
+    const matches = [];
+    let after;
+    for (let page = 0; page < 10; page += 1) {
+        const result = await request(context, "webhook list", {
+            endpoint,
+            method: "GET",
+            query: {
+                "filter[name_contains]": name(context.endpointUrl),
+                "page[size]": "100",
+                ...(after == null ? {} : { "page[after]": after }),
+            },
+        });
+        success(result, "webhook list");
+        const listing = record(result.data);
+        const webhooks = Array.isArray(listing?.webhooks) ? listing.webhooks : [];
+        for (const item of webhooks) {
+            const value = record(item);
+            if (value?.endpoint === context.endpointUrl && typeof value.id == "string")
+                matches.push(value.id);
+        }
+        const meta = record(listing?.meta);
+        if (meta?.has_more !== true || typeof meta.after_cursor != "string")
+            return matches;
+        after = meta.after_cursor;
+    }
+    return matches;
+}
+async function remove(context, webhookId) {
+    const result = await request(context, "webhook delete", {
+        endpoint: `${endpoint}/${webhookId}`,
+        method: "DELETE",
+    });
+    if (result.status != 404)
+        success(result, "webhook delete");
+}
+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(`Zendesk ${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(`Zendesk ${operation} rejected the Connection.`);
+    if ([400, 404, 422].includes(result.status))
+        throw new PermanentIntegrationError(`Zendesk ${operation} rejected the subscription.`);
+    throw new TransientIntegrationError(`Zendesk ${operation} failed with status ${result.status}.`);
+}
+function name(url) {
+    return `open-flow-${url.slice(url.lastIndexOf("/") + 1)}`;
+}
+function readId(value) {
+    const webhookId = record(value)?.id;
+    if (typeof webhookId != "string")
+        throw new TransientIntegrationError("Zendesk webhook response is missing its ID.");
+    return webhookId;
+}
+function requireState(value) {
+    if (value == null)
+        throw new PermanentIntegrationError("Zendesk Integration state is missing.");
+    return value;
+}
+function subscriptionId(state) {
+    const value = state.subscription.webhookId;
+    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 readSigningSecret(context, webhookId) {
+    const result = await request(context, "webhook signing secret", {
+        endpoint: `${endpoint}/${webhookId}/signing_secret`,
+        method: "GET",
+    });
+    success(result, "webhook signing secret");
+    const secret = record(record(result.data)?.signing_secret)?.secret;
+    if (typeof secret != "string" || secret.length == 0)
+        throw new TransientIntegrationError("Zendesk webhook signing secret response is invalid.");
+    return secret;
+}
+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/zerotier/executors.d.ts

@@ -0,0 +1,9 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { ProviderActionHandlers, ProviderRuntimeHandler } from "../provider-runtime.ts";
+import type { ZerotierActionContext } from "./runtime.ts";
+type ZerotierHandler = ProviderRuntimeHandler<ZerotierActionContext>;
+export declare const zerotierActionHandlers: ProviderActionHandlers<"zerotier", ZerotierHandler>;
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;
+export declare const credentialValidators: CredentialValidators;
+export {};