@revenexx/studio-integrations 0.1.0

package/dist/runtime/composables/useIntegrationsCredentials.js

@@ -0,0 +1,98 @@
+import { computed } from "vue";
+import { IntegrationsApiError, useIntegrationsApi } from "./integrationsApi.js";
+export function useIntegrationsCredentials() {
+  const credentials = useState("integrations.credentials", () => []);
+  const loading = useState("integrations.credentials.loading", () => false);
+  const error = useState("integrations.credentials.error", () => null);
+  const loaded = useState("integrations.credentials.loaded", () => false);
+  const api = useIntegrationsApi();
+  function normalize(res) {
+    const obj = res;
+    if (Array.isArray(obj)) return obj;
+    if (Array.isArray(obj?.data)) return obj.data;
+    return [];
+  }
+  function unwrap(res) {
+    return res?.data ?? res;
+  }
+  function captureError(e, fallback) {
+    if (e instanceof IntegrationsApiError) return e.message;
+    return e?.message ?? fallback;
+  }
+  async function load(force = false) {
+    if (loading.value) return credentials.value;
+    if (loaded.value && !force) return credentials.value;
+    loading.value = true;
+    error.value = null;
+    try {
+      credentials.value = normalize(await api.get("/credentials"));
+      loaded.value = true;
+    } catch (e) {
+      error.value = captureError(e, "Could not load credentials.");
+    } finally {
+      loading.value = false;
+    }
+    return credentials.value;
+  }
+  function ofType(slug) {
+    return credentials.value.filter((c) => c.credential_type_slug === slug);
+  }
+  async function get(id) {
+    return unwrap(await api.get(`/credentials/${encodeURIComponent(id)}`));
+  }
+  async function create(input) {
+    const created = unwrap(await api.post("/credentials", input));
+    await load(true);
+    return created;
+  }
+  async function update(id, input) {
+    const updated = unwrap(await api.patch(`/credentials/${encodeURIComponent(id)}`, input));
+    await load(true);
+    return updated;
+  }
+  async function remove(id) {
+    await api.del(`/credentials/${encodeURIComponent(id)}`);
+    credentials.value = credentials.value.filter((c) => c.id !== id);
+  }
+  async function testInline(credentialTypeSlug, config) {
+    try {
+      const res = await api.post("/credentials/test", { credential_type_slug: credentialTypeSlug, config });
+      return res?.ok === false ? res : { ok: true };
+    } catch (e) {
+      return { ok: false, error: captureError(e, "Connection test failed.") };
+    }
+  }
+  async function test(id) {
+    try {
+      const res = await api.post(`/credentials/${encodeURIComponent(id)}/test`);
+      return res?.ok === false ? res : { ok: true };
+    } catch (e) {
+      return { ok: false, error: captureError(e, "Connection test failed.") };
+    }
+  }
+  async function oauthAuthorizeUrl(id) {
+    const res = await api.post(`/credentials/${encodeURIComponent(id)}/oauth/authorize-url`);
+    const authorizeUrl = res?.authorize_url ?? res?.data?.authorize_url;
+    if (!authorizeUrl) throw new IntegrationsApiError(0, res, "No authorize URL returned.");
+    return authorizeUrl;
+  }
+  const total = computed(() => credentials.value.length);
+  const needsReauth = computed(() => credentials.value.filter((c) => c.status === "needs_reauth"));
+  return {
+    credentials,
+    loading,
+    error,
+    loaded,
+    total,
+    needsReauth,
+    load,
+    ofType,
+    get,
+    create,
+    update,
+    remove,
+    testInline,
+    test,
+    oauthAuthorizeUrl
+  };
+}

package/dist/runtime/composables/useIntegrationsFocus.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tracks whether the Integration Studio is in "focus mode" — i.e. the
+ * left sidebar (with `Integration Studio` header + sections) is hidden so
+ * the canvas can run edge-to-edge.
+ *
+ * Pages opt in by calling `useIntegrationsFocus().enable()` in onMounted
+ * and `disable()` in onUnmounted (we provide an `autoEnable()` helper
+ * that wires both).
+ */
+export declare function useIntegrationsFocus(): {
+    focused: any;
+    enable: () => void;
+    disable: () => void;
+    toggle: () => void;
+    autoEnable: () => void;
+};

package/dist/runtime/composables/useIntegrationsFocus.js

@@ -0,0 +1,17 @@
+export function useIntegrationsFocus() {
+  const focused = useState("integrations.focus", () => false);
+  function enable() {
+    focused.value = true;
+  }
+  function disable() {
+    focused.value = false;
+  }
+  function toggle() {
+    focused.value = !focused.value;
+  }
+  function autoEnable() {
+    onMounted(() => enable());
+    onUnmounted(() => disable());
+  }
+  return { focused, enable, disable, toggle, autoEnable };
+}

package/dist/runtime/composables/useIntegrationsNodes.d.ts

@@ -0,0 +1,6 @@
+export declare function useIntegrationsNodes(): {
+    loading: any;
+    error: any;
+    loaded: any;
+    load: (force?: boolean) => Promise<void>;
+};

package/dist/runtime/composables/useIntegrationsNodes.js

@@ -0,0 +1,32 @@
+import { applyNodeCatalog } from "../data/integrationNodeCatalog.js";
+import { IntegrationsApiError, useIntegrationsApi } from "./integrationsApi.js";
+export function useIntegrationsNodes() {
+  const loading = useState("integrations.nodes.loading", () => false);
+  const error = useState("integrations.nodes.error", () => null);
+  const loaded = useState("integrations.nodes.loaded", () => false);
+  const api = useIntegrationsApi();
+  async function load(force = false) {
+    if (loading.value) return;
+    if (loaded.value && !force) return;
+    loading.value = true;
+    error.value = null;
+    try {
+      const res = await api.get("/nodes");
+      const list = Array.isArray(res) ? res : res?.data ?? [];
+      const manifests = list.filter((n) => n.manifest).map((n) => ({
+        ...n.manifest,
+        slug: n.manifest.slug ?? n.slug,
+        version: n.manifest.version ?? n.version,
+        name: n.manifest.name ?? n.name
+      }));
+      applyNodeCatalog(manifests);
+      loaded.value = true;
+    } catch (e) {
+      applyNodeCatalog([]);
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? "Could not load nodes.";
+    } finally {
+      loading.value = false;
+    }
+  }
+  return { loading, error, loaded, load };
+}

package/dist/runtime/composables/useIntegrationsRuns.d.ts

@@ -0,0 +1,31 @@
+import type { RunStatus, WorkflowRun } from '../types/integrations.js';
+export declare function useIntegrationsRuns(): {
+    runs: any;
+    loading: any;
+    error: any;
+    loaded: any;
+    total: import("vue").ComputedRef<any>;
+    failedCount: import("vue").ComputedRef<any>;
+    runningCount: import("vue").ComputedRef<any>;
+    load: (force?: boolean) => Promise<WorkflowRun[]>;
+    list: (filter?: {
+        workflowId?: number;
+        status?: RunStatus;
+    }) => WorkflowRun[];
+    get: (id: string) => WorkflowRun | null;
+    trigger: (workflowId: number | string, payload?: Record<string, unknown>, mode?: "sync" | "async") => Promise<unknown>;
+    getRun: (workflowId: number | string, runId: number | string) => Promise<unknown>;
+    getDetails: (workflowId: number | string, runId: number | string) => Promise<{
+        source: string;
+        data: Record<string, unknown>;
+    }>;
+    getHistory: (workflowId: number | string, runId: number | string, params?: {
+        page_token?: string;
+        page_size?: number;
+    }) => Promise<{
+        source: string;
+        data: unknown[];
+        next_page_token: string | null;
+    }>;
+    getStackTrace: (workflowId: number | string, runId: number | string) => Promise<string>;
+};

package/dist/runtime/composables/useIntegrationsRuns.js

@@ -0,0 +1,109 @@
+import { computed } from "vue";
+import { IntegrationsApiError, useIntegrationsApi } from "./integrationsApi.js";
+function mapStatus(status) {
+  switch (status) {
+    case "completed":
+      return "succeeded";
+    case "pending":
+      return "queued";
+    case "terminated":
+      return "failed";
+    case "running":
+      return "running";
+    case "failed":
+      return "failed";
+    case "cancelled":
+      return "cancelled";
+    default:
+      return "running";
+  }
+}
+export function useIntegrationsRuns() {
+  const runs = useState("integrations.runs", () => []);
+  const loading = useState("integrations.runs.loading", () => false);
+  const error = useState("integrations.runs.error", () => null);
+  const loaded = useState("integrations.runs.loaded", () => false);
+  const api = useIntegrationsApi();
+  const { workflows, load: loadWorkflows } = useIntegrationsWorkflows();
+  function mapRun(r, workflowName) {
+    return {
+      id: String(r.id),
+      workflowId: r.workflow_id,
+      workflowName,
+      status: mapStatus(r.status),
+      triggerId: "",
+      triggerType: "manual",
+      startedAt: r.started_at ?? "",
+      finishedAt: r.completed_at ?? null,
+      durationMs: null,
+      steps: []
+    };
+  }
+  async function load(force = false) {
+    if (loading.value) return runs.value;
+    if (loaded.value && !force) return runs.value;
+    loading.value = true;
+    error.value = null;
+    try {
+      await loadWorkflows();
+      const perWorkflow = await Promise.allSettled(
+        workflows.value.map(async (wf) => {
+          const res = await api.get(`/workflows/${wf.id}/runs`);
+          return (res?.data ?? []).map((r) => mapRun(r, wf.name));
+        })
+      );
+      runs.value = perWorkflow.flatMap((p) => p.status === "fulfilled" ? p.value : []).sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+      loaded.value = true;
+    } catch (e) {
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? "Could not load runs.";
+    } finally {
+      loading.value = false;
+    }
+    return runs.value;
+  }
+  function list(filter) {
+    let result = [...runs.value];
+    if (filter?.workflowId !== void 0) result = result.filter((r) => r.workflowId === filter.workflowId);
+    if (filter?.status) result = result.filter((r) => r.status === filter.status);
+    return result.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+  }
+  function get(id) {
+    return runs.value.find((r) => r.id === id) ?? null;
+  }
+  async function trigger(workflowId, payload = {}, mode) {
+    const body = { trigger_payload: payload };
+    if (mode) body.mode = mode;
+    const res = await api.post(`/workflows/${workflowId}/runs`, body);
+    return res?.data ?? res;
+  }
+  const getRun = (workflowId, runId) => api.get(`/workflows/${workflowId}/runs/${runId}`);
+  const getDetails = (workflowId, runId) => api.get(`/workflows/${workflowId}/runs/${runId}/details`);
+  const getHistory = (workflowId, runId, params = {}) => {
+    const qs = new URLSearchParams();
+    if (params.page_token) qs.set("page_token", params.page_token);
+    if (params.page_size) qs.set("page_size", String(params.page_size));
+    const suffix = qs.toString() ? `?${qs}` : "";
+    return api.get(`/workflows/${workflowId}/runs/${runId}/history${suffix}`);
+  };
+  const getStackTrace = (workflowId, runId) => api.get(`/workflows/${workflowId}/runs/${runId}/stack-trace`).then((r) => r.stack_trace);
+  const total = computed(() => runs.value.length);
+  const failedCount = computed(() => runs.value.filter((r) => r.status === "failed").length);
+  const runningCount = computed(() => runs.value.filter((r) => r.status === "running").length);
+  return {
+    runs,
+    loading,
+    error,
+    loaded,
+    total,
+    failedCount,
+    runningCount,
+    load,
+    list,
+    get,
+    trigger,
+    getRun,
+    getDetails,
+    getHistory,
+    getStackTrace
+  };
+}

package/dist/runtime/composables/useIntegrationsSchedules.d.ts

@@ -0,0 +1,14 @@
+import type { ScheduleEntry } from '../types/integrations.js';
+/**
+ * Derived view — every trigger of type `schedule` across all workflows,
+ * sourced from the real triggers sub-resource (useIntegrationsTriggers).
+ * Next/last-run timestamps are mocked deterministically (no telemetry
+ * endpoint yet).
+ */
+export declare function useIntegrationsSchedules(): {
+    entries: import("vue").ComputedRef<ScheduleEntry[]>;
+    total: import("vue").ComputedRef<number>;
+    activeCount: import("vue").ComputedRef<number>;
+    loading: any;
+    load: any;
+};

package/dist/runtime/composables/useIntegrationsSchedules.js

@@ -0,0 +1,32 @@
+import { computed } from "vue";
+export function useIntegrationsSchedules() {
+  const { all, loading, loadAll } = useIntegrationsTriggers();
+  const entries = computed(
+    () => all.value.filter((t) => t.type === "schedule").map((t) => {
+      const cfg = t.config ?? {};
+      const triggerId = String(t.id);
+      return {
+        id: `${t.workflow_id}:${t.id}`,
+        workflowId: t.workflow_id,
+        workflowName: t.workflowName,
+        triggerId,
+        cron: String(cfg.cron ?? "* * * * *"),
+        timezone: String(cfg.timezone ?? "UTC"),
+        active: t.active,
+        nextRunAt: t.active ? mockNextRun(t.workflow_id, triggerId) : null,
+        lastRunAt: t.active ? mockLastRun(t.workflow_id, triggerId) : null
+      };
+    }).sort((a, b) => a.cron.localeCompare(b.cron))
+  );
+  const total = computed(() => entries.value.length);
+  const activeCount = computed(() => entries.value.filter((e) => e.active).length);
+  return { entries, total, activeCount, loading, load: loadAll };
+}
+function mockNextRun(workflowId, triggerId) {
+  const offsetMinutes = (workflowId * 7 + triggerId.length * 3) % 720 + 5;
+  return new Date(Date.now() + offsetMinutes * 6e4).toISOString();
+}
+function mockLastRun(workflowId, triggerId) {
+  const offsetMinutes = (workflowId * 13 + triggerId.length * 11) % 720 + 30;
+  return new Date(Date.now() - offsetMinutes * 6e4).toISOString();
+}

package/dist/runtime/composables/useIntegrationsSecrets.d.ts

@@ -0,0 +1,27 @@
+import type { SecretRecord } from '../types/integrations.js';
+/**
+ * Per-tenant encrypted key/value store, backed by the Integrations service
+ * (`/api/v1/secrets`). The backend NEVER returns values — only keys +
+ * timestamps — so the list is keys-only by design.
+ *
+ *   GET    /secrets          → list (keys + timestamps)
+ *   POST   /secrets          → upsert  { key, value }
+ *   DELETE /secrets/{key}    → remove
+ */
+export declare function useIntegrationsSecrets(): {
+    secrets: any;
+    loading: any;
+    error: any;
+    loaded: any;
+    total: import("vue").ComputedRef<any>;
+    keys: import("vue").ComputedRef<any>;
+    isValidKey: (key: string) => boolean;
+    KEY_PATTERN: RegExp;
+    load: (force?: boolean) => Promise<SecretRecord[]>;
+    list: () => Promise<SecretRecord[]>;
+    upsert: (key: string, value: string) => Promise<{
+        record: SecretRecord;
+        created: boolean;
+    }>;
+    remove: (key: string) => Promise<boolean>;
+};

package/dist/runtime/composables/useIntegrationsSecrets.js

@@ -0,0 +1,76 @@
+import { computed } from "vue";
+import { IntegrationsApiError, useIntegrationsApi } from "./integrationsApi.js";
+const KEY_PATTERN = /^[A-Z0-9_]+$/;
+export function useIntegrationsSecrets() {
+  const secrets = useState("integrations.secrets", () => []);
+  const loading = useState("integrations.secrets.loading", () => false);
+  const error = useState("integrations.secrets.error", () => null);
+  const loaded = useState("integrations.secrets.loaded", () => false);
+  const api = useIntegrationsApi();
+  function isValidKey(key) {
+    return KEY_PATTERN.test(key);
+  }
+  function normalize(res) {
+    const obj = res;
+    if (Array.isArray(obj?.keys)) return obj.keys.map((key) => ({ key, created_at: "", updated_at: "" }));
+    if (Array.isArray(obj?.data)) return obj.data;
+    if (Array.isArray(obj?.secrets)) return obj.secrets;
+    if (Array.isArray(res)) return res;
+    return [];
+  }
+  function captureError(e, fallback) {
+    if (e instanceof IntegrationsApiError) return e.message;
+    return e?.message ?? fallback;
+  }
+  async function load(force = false) {
+    if (loading.value) return secrets.value;
+    if (loaded.value && !force) return secrets.value;
+    loading.value = true;
+    error.value = null;
+    try {
+      secrets.value = normalize(await api.get("/secrets"));
+      loaded.value = true;
+    } catch (e) {
+      error.value = captureError(e, "Could not load secrets.");
+    } finally {
+      loading.value = false;
+    }
+    return secrets.value;
+  }
+  async function list() {
+    if (!loaded.value) await load();
+    return [...secrets.value].sort((a, b) => a.key.localeCompare(b.key));
+  }
+  async function upsert(key, value) {
+    if (!isValidKey(key)) {
+      throw new Error("Key must match ^[A-Z0-9_]+$");
+    }
+    const created = !secrets.value.some((s) => s.key === key);
+    await api.post("/secrets", { key, value });
+    await load(true);
+    const record = secrets.value.find((s) => s.key === key) ?? { key, created_at: (/* @__PURE__ */ new Date()).toISOString(), updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+    return { record, created };
+  }
+  async function remove(key) {
+    const before = secrets.value.length;
+    await api.del(`/secrets/${encodeURIComponent(key)}`);
+    secrets.value = secrets.value.filter((s) => s.key !== key);
+    return secrets.value.length !== before;
+  }
+  const total = computed(() => secrets.value.length);
+  const keys = computed(() => secrets.value.map((s) => s.key).sort());
+  return {
+    secrets,
+    loading,
+    error,
+    loaded,
+    total,
+    keys,
+    isValidKey,
+    KEY_PATTERN,
+    load,
+    list,
+    upsert,
+    remove
+  };
+}

package/dist/runtime/composables/useIntegrationsTemplates.d.ts

@@ -0,0 +1,19 @@
+import type { TemplateRequirements, WorkflowTemplate } from '../types/integrations.js';
+export declare function useIntegrationsTemplates(): {
+    templates: any;
+    loaded: any;
+    loading: any;
+    error: any;
+    total: import("vue").ComputedRef<any>;
+    popular: import("vue").ComputedRef<any[]>;
+    load: (force?: boolean) => Promise<WorkflowTemplate[]>;
+    list: () => WorkflowTemplate[];
+    get: (slug: string) => WorkflowTemplate | null;
+    fetchDetail: (slug: string) => Promise<WorkflowTemplate | null>;
+    requirements: (slug: string) => Promise<TemplateRequirements | null>;
+    instantiate: (slug: string, opts?: {
+        name?: string;
+        credentialBindings?: Record<string, string>;
+    }) => Promise<number | null>;
+    install: (slug: string) => Promise<number | null>;
+};

package/dist/runtime/composables/useIntegrationsTemplates.js

@@ -0,0 +1,141 @@
+import { computed } from "vue";
+import { IntegrationsApiError, useIntegrationsApi } from "./integrationsApi.js";
+import { resolveLocalized } from "../utils/localize.js";
+const BLOB_VERSION = "v0-draft";
+const INDUSTRY_VALUES = ["mechanical-engineering", "chemicals", "wholesale", "manufacturing", "retail", "any"];
+function publisherFor(slug, vendors) {
+  const ns = slug.includes(":") ? slug.split(":")[0] : vendors[0] ?? "revenexx";
+  const kind = ns === "revenexx" ? "revenexx" : "partner";
+  return { name: ns, kind };
+}
+function mapIndustries(arr) {
+  return (arr ?? []).filter((i) => INDUSTRY_VALUES.includes(i));
+}
+function emptyBlob(name) {
+  return { nodeManifestVersion: BLOB_VERSION, name, nodes: [], edges: [], triggerPositions: {}, triggers: [] };
+}
+function mapListItem(api) {
+  return {
+    slug: api.slug,
+    name: resolveLocalized(api.name),
+    description: resolveLocalized(api.description || api.shortDescription || ""),
+    category: api.category ?? "sync",
+    industries: mapIndustries(api.industries),
+    vendors: api.vendors ?? [],
+    requiredSecrets: [],
+    level: api.level ?? "beginner",
+    outline: [],
+    nodeCount: 0,
+    installs: 0,
+    publisher: publisherFor(api.slug, api.vendors ?? []),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    blob: emptyBlob(resolveLocalized(api.name)),
+    fromApi: true
+  };
+}
+function applyDetail(base, api) {
+  const def = api.definition ?? {};
+  const triggers = (api.triggers ?? []).map((t) => ({
+    id: t.handle ?? String(t.id ?? ""),
+    type: t.type,
+    name: typeof t.name === "string" ? t.name : void 0,
+    active: t.active,
+    config: t.config ?? {}
+  }));
+  const nodes = def.nodes ?? [];
+  const blob = {
+    nodeManifestVersion: def.nodeManifestVersion ?? BLOB_VERSION,
+    name: def.name ?? base.name,
+    nodes,
+    edges: def.edges ?? [],
+    triggerPositions: {},
+    triggers
+  };
+  return {
+    ...base,
+    description: resolveLocalized(api.description || api.shortDescription || "") || base.description,
+    blob,
+    nodeCount: nodes.length,
+    outline: nodes.map((n) => n.nodeSlug ?? n.id).filter(Boolean)
+  };
+}
+export function useIntegrationsTemplates() {
+  const templates = useState("integrations.templates", () => []);
+  const loaded = useState("integrations.templates.loaded", () => false);
+  const loading = useState("integrations.templates.loading", () => false);
+  const error = useState("integrations.templates.error", () => null);
+  const api = useIntegrationsApi();
+  function unwrap(res) {
+    return res?.data ?? res;
+  }
+  function captureError(e, fallback) {
+    return e instanceof IntegrationsApiError ? e.message : e?.message ?? fallback;
+  }
+  async function load(force = false) {
+    if (loading.value) return templates.value;
+    if (loaded.value && !force) return templates.value;
+    loading.value = true;
+    error.value = null;
+    try {
+      const list2 = unwrap(await api.get("/templates")) ?? [];
+      templates.value = list2.map(mapListItem);
+      loaded.value = true;
+    } catch (e) {
+      error.value = captureError(e, "Could not load templates.");
+      templates.value = [];
+      loaded.value = true;
+    } finally {
+      loading.value = false;
+    }
+    return templates.value;
+  }
+  function list() {
+    return templates.value;
+  }
+  function get(slug) {
+    return templates.value.find((t) => t.slug === slug) ?? null;
+  }
+  async function fetchDetail(slug) {
+    const base = get(slug);
+    if (!base?.fromApi) return base;
+    try {
+      const detail = unwrap(await api.get(`/templates/${slug}`));
+      const merged = applyDetail(base, detail);
+      templates.value = templates.value.map((t) => t.slug === slug ? merged : t);
+      return merged;
+    } catch {
+      return base;
+    }
+  }
+  async function requirements(slug) {
+    try {
+      const raw = unwrap(await api.get(`/templates/${slug}/requirements`));
+      if (!raw) return null;
+      return {
+        ...raw,
+        credentialTypes: (raw.credentialTypes ?? []).map((c) => ({
+          ...c,
+          name: c.name ? resolveLocalized(c.name) : c.name
+        }))
+      };
+    } catch {
+      return null;
+    }
+  }
+  async function instantiate(slug, opts = {}) {
+    const body = {};
+    if (opts.name) body.name = opts.name;
+    const bindings = Object.fromEntries(
+      Object.entries(opts.credentialBindings ?? {}).filter(([, v]) => v)
+    );
+    if (Object.keys(bindings).length) body.credential_bindings = bindings;
+    const created = unwrap(await api.post(`/templates/${slug}/instantiate`, body));
+    return Number(created.id);
+  }
+  async function install(slug) {
+    return instantiate(slug);
+  }
+  const total = computed(() => templates.value.length);
+  const popular = computed(() => [...templates.value].sort((a, b) => b.installs - a.installs).slice(0, 4));
+  return { templates, loaded, loading, error, total, popular, load, list, get, fetchDetail, requirements, instantiate, install };
+}

package/dist/runtime/composables/useIntegrationsTriggers.d.ts

@@ -0,0 +1,39 @@
+import type { TriggerType } from '../types/integrations.js';
+/**
+ * Workflow triggers — a per-workflow sub-resource in the Integrations service
+ * (`/workflows/{id}/triggers`), NOT part of the workflow blob. The global
+ * Schedules / Webhooks views fan `loadAll()` out across the tenant's workflows
+ * and filter by `type`.
+ */
+export interface ApiTrigger {
+    id: number;
+    workflow_id: number;
+    handle: string;
+    type: TriggerType;
+    name?: string | Record<string, string> | null;
+    config?: Record<string, unknown> | null;
+    active: boolean;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface TriggerWithWorkflow extends ApiTrigger {
+    workflowName: string;
+}
+export interface TriggerInput {
+    handle: string;
+    type: TriggerType;
+    name?: string | null;
+    config?: Record<string, unknown> | null;
+    active?: boolean;
+}
+export declare function useIntegrationsTriggers(): {
+    all: any;
+    loading: any;
+    error: any;
+    loaded: any;
+    list: (workflowId: number | string) => Promise<ApiTrigger[]>;
+    loadAll: (force?: boolean) => Promise<TriggerWithWorkflow[]>;
+    create: (workflowId: number | string, data: TriggerInput) => Promise<ApiTrigger>;
+    update: (workflowId: number | string, triggerId: number, data: Omit<TriggerInput, "handle">) => Promise<ApiTrigger>;
+    remove: (workflowId: number | string, triggerId: number) => Promise<unknown>;
+};