@bpmnkit/connectors 0.1.0

package/dist/catalog.js

@@ -0,0 +1,195 @@
+import { CAMUNDA_CONNECTOR_TEMPLATES } from "./templates/generated.js";
+const SECRET_PATTERN = /token|secret|password|api.?key|apikey|credential|access.?key/i;
+function isSecretField(prop, key) {
+    return SECRET_PATTERN.test(`${prop.label ?? ""} ${key}`);
+}
+/** Same key-derivation logic used at apply time — kept in sync with `apply.ts`. */
+export function propertyKey(prop) {
+    if (prop.id)
+        return prop.id;
+    const b = prop.binding;
+    if (b.type === "zeebe:input")
+        return b.name;
+    if (b.type === "zeebe:output")
+        return b.source;
+    if (b.type === "zeebe:taskHeader")
+        return b.key;
+    if (b.type === "zeebe:taskDefinition")
+        return `taskDef.${b.property}`;
+    if (b.type === "zeebe:taskDefinition:type")
+        return "taskDef.type";
+    if (b.type === "property")
+        return b.name;
+    if (b.type === "zeebe:property")
+        return b.name;
+    if (b.type === "zeebe:adHoc")
+        return `adHoc.${b.property}`;
+    return "";
+}
+function toInputSpec(prop) {
+    const key = propertyKey(prop);
+    return {
+        key,
+        label: prop.label ?? key,
+        description: prop.description,
+        isSecret: isSecretField(prop, key),
+        isFeel: prop.feel === "required" || prop.feel === "optional",
+        default: prop.value,
+        choices: prop.choices,
+        condition: prop.condition,
+    };
+}
+function taskDefinitionType(template) {
+    for (const prop of template.properties) {
+        if (prop.binding.type === "zeebe:taskDefinition" && prop.binding.property === "type") {
+            return typeof prop.value === "string" ? prop.value : undefined;
+        }
+        if (prop.binding.type === "zeebe:taskDefinition:type") {
+            return typeof prop.value === "string" ? prop.value : undefined;
+        }
+    }
+    return undefined;
+}
+function directionOf(template) {
+    const elementType = template.elementType?.value ?? template.appliesTo[0];
+    switch (elementType) {
+        case "bpmn:AdHocSubProcess":
+            return "agentic";
+        case "bpmn:StartEvent":
+            return "inbound-start";
+        case "bpmn:IntermediateCatchEvent":
+        case "bpmn:IntermediateThrowEvent":
+        case "bpmn:ReceiveTask":
+            return "inbound-intermediate";
+        case "bpmn:BoundaryEvent":
+            return "inbound-boundary";
+        default:
+            return "outbound";
+    }
+}
+function keywordsOf(template) {
+    const words = new Set();
+    for (const raw of `${template.name} ${template.description ?? ""}`
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)) {
+        if (raw.length > 2)
+            words.add(raw);
+    }
+    return [...words];
+}
+/**
+ * What a template will do, without applying it.
+ *
+ * The catalogue computes this for every listing already; it is exported because
+ * anything offering a template to a person needs to be able to say what it
+ * binds and what it will ask for — a picker that applies on the first click is
+ * asking someone to choose blind.
+ *
+ * @param template - The template to describe.
+ */
+export function summarizeTemplate(template) {
+    const visible = template.properties.filter((p) => p.type !== "Hidden");
+    return {
+        id: template.id,
+        name: template.name,
+        description: template.description,
+        taskType: taskDefinitionType(template),
+        appliesTo: template.appliesTo,
+        direction: directionOf(template),
+        keywords: keywordsOf(template),
+        requiredInputs: visible.filter((p) => p.constraints?.notEmpty === true).map(toInputSpec),
+        optionalInputs: visible.filter((p) => p.constraints?.notEmpty !== true).map(toInputSpec),
+    };
+}
+/**
+ * Templates a host has registered on top of the bundled catalogue — a project's
+ * own `.camunda/element-templates/`, or anything else it has that the bundle
+ * does not.
+ *
+ * Kept separate rather than merged into one array so the bundle stays the
+ * constant it is declared to be, and so `clearRegisteredTemplates()` is exact.
+ */
+const registered = new Map();
+let cachedSummaries;
+/**
+ * Adds templates to the catalogue, replacing any bundled template with the same
+ * id.
+ *
+ * The workspace wins deliberately: a project that ships its own version of a
+ * connector means it, and the bundle is the fallback. Registering the same id
+ * twice keeps the later one, so a nearer directory can override a further one.
+ *
+ * @param templates - Validated templates. Nothing is checked here; run
+ *   `validateElementTemplate` (or `readTemplateDocument`) at the boundary where
+ *   the JSON was read, so a bad file is reported against its own path.
+ */
+export function registerElementTemplates(templates) {
+    for (const template of templates)
+        registered.set(template.id, template);
+    cachedSummaries = undefined;
+}
+/** Drops every registered template, leaving only the bundled catalogue. */
+export function clearRegisteredTemplates() {
+    registered.clear();
+    cachedSummaries = undefined;
+}
+/** The bundled templates plus registered ones, the latter winning on id. */
+function allTemplates() {
+    if (registered.size === 0)
+        return CAMUNDA_CONNECTOR_TEMPLATES;
+    const bundled = CAMUNDA_CONNECTOR_TEMPLATES.filter((t) => !registered.has(t.id));
+    return [...bundled, ...registered.values()];
+}
+/** Every connector template — bundled and registered — as a compact summary. */
+export function listConnectors() {
+    if (!cachedSummaries) {
+        cachedSummaries = allTemplates().map(summarizeTemplate);
+    }
+    return cachedSummaries;
+}
+/** The full element template for a given template id, registered or bundled. */
+export function getTemplate(id) {
+    return registered.get(id) ?? CAMUNDA_CONNECTOR_TEMPLATES.find((t) => t.id === id);
+}
+/** Tie-break preference when two templates score equally — outbound "do this" connectors are the common case. */
+const DIRECTION_RANK = {
+    outbound: 0,
+    agentic: 1,
+    "inbound-start": 2,
+    "inbound-intermediate": 3,
+    "inbound-boundary": 4,
+};
+/**
+ * Keyword-scored search over the bundled connector catalog — mirrors
+ * `@bpmnkit/patterns`' `findPattern()` matching style. Matches against the
+ * template name are weighted highest, then keyword-list matches, then a
+ * general substring match; ties prefer outbound connectors.
+ */
+export function searchConnectors(query) {
+    const terms = query
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length > 1);
+    if (terms.length === 0)
+        return [];
+    const scored = listConnectors()
+        .map((summary) => {
+        const nameWords = new Set(summary.name.toLowerCase().split(/[^a-z0-9]+/));
+        const haystack = `${summary.name} ${summary.description ?? ""} ${summary.keywords.join(" ")} ${summary.taskType ?? ""}`.toLowerCase();
+        let score = 0;
+        for (const term of terms) {
+            if (nameWords.has(term))
+                score += 4;
+            else if (summary.keywords.includes(term))
+                score += 3;
+            else if (haystack.includes(term))
+                score += 1;
+        }
+        return { summary, score };
+    })
+        .filter((s) => s.score > 0)
+        .sort((a, b) => b.score - a.score ||
+        DIRECTION_RANK[a.summary.direction] - DIRECTION_RANK[b.summary.direction]);
+    return scored.map((s) => s.summary);
+}
+//# sourceMappingURL=catalog.js.map

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { listConnectors, searchConnectors, getTemplate, propertyKey, registerElementTemplates, clearRegisteredTemplates, summarizeTemplate, } from "./catalog.js";
+export type { ConnectorSummary, ConnectorInputSpec, ConnectorDirection } from "./catalog.js";
+export { applyConnectorTemplate, applyElementTemplate } from "./apply.js";
+export type { ApplyResult, ApplyProblem } from "./apply.js";
+export { CAMUNDA_CONNECTOR_TEMPLATES } from "./templates/generated.js";
+export type { ElementTemplate, TemplateGroup, TemplateProperty, TemplateBinding, TemplateCondition, } from "./template-types.js";
+export { validateElementTemplate, readTemplateDocument } from "./validate.js";
+export type { TemplateProblem, TemplateValidation, TemplateDocumentResult, } from "./validate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,5 @@
+export { listConnectors, searchConnectors, getTemplate, propertyKey, registerElementTemplates, clearRegisteredTemplates, summarizeTemplate, } from "./catalog.js";
+export { applyConnectorTemplate, applyElementTemplate } from "./apply.js";
+export { CAMUNDA_CONNECTOR_TEMPLATES } from "./templates/generated.js";
+export { validateElementTemplate, readTemplateDocument } from "./validate.js";
+//# sourceMappingURL=index.js.map

package/dist/node/discover.d.ts

@@ -0,0 +1,90 @@
+import type { ElementTemplate } from "../template-types.js";
+import { type TemplateProblem } from "../validate.js";
+/** The folder name searched at each level, unless the caller names another. */
+export declare const DEFAULT_CONFIG_FOLDER = ".camunda";
+/** The sub-folder inside the config folder that holds templates. */
+export declare const TEMPLATES_SUBFOLDER = "element-templates";
+export interface DiscoverOptions {
+    /**
+     * Where to start looking — a `.bpmn` file, or the directory holding it.
+     * The search walks up from here.
+     */
+    from: string;
+    /**
+     * Where to stop. The walk includes this directory and goes no further, so a
+     * template outside the project cannot be picked up by accident. Defaults to
+     * the filesystem root, which is almost never what a caller wants.
+     */
+    root?: string;
+    /** Config folder name. Defaults to `.camunda`. */
+    configFolder?: string;
+}
+/** A template that could not be used, and where it came from. */
+export interface DiscoveryProblem extends TemplateProblem {
+    /** Absolute path of the file the problem was found in. */
+    file: string;
+    /** The template's id, when the document got far enough to have one. */
+    id?: string;
+    /** Index within the file, for a document holding an array of templates. */
+    index?: number;
+}
+export interface DiscoveryResult {
+    /** Valid templates, nearest directory last so a later register wins. */
+    templates: ElementTemplate[];
+    /** Everything rejected, each named by file — nothing is dropped silently. */
+    problems: DiscoveryProblem[];
+    /** Valid but worth saying, e.g. a binding this toolkit cannot apply yet. */
+    warnings: DiscoveryProblem[];
+    /** The template directories that were read, nearest last. */
+    directories: string[];
+}
+/**
+ * Finds a project's own element templates by convention.
+ *
+ * Every directory from `root` down to the one holding `from` is checked for
+ * `<configFolder>/element-templates/*.json`. No project configuration, no
+ * registration step: drop a template next to the diagram that uses it and the
+ * tools pick it up.
+ *
+ * Order is deliberate. Directories are read root-first so the nearest one is
+ * read last, and `registerElementTemplates` keeps the last registration of an
+ * id — a template beside the diagram overrides one at the project root, which
+ * overrides the bundled catalogue.
+ *
+ * A file that is not valid JSON, or holds a template the schema rejects, is
+ * reported in `problems` against its own path and left out of `templates`. One
+ * bad file never costs the caller the good ones beside it.
+ *
+ * @example
+ * ```typescript
+ * const { templates, problems } = await discoverElementTemplates({
+ *   from: "processes/orders/order.bpmn",
+ *   root: process.cwd(),
+ * });
+ * registerElementTemplates(templates);
+ * ```
+ */
+export declare function discoverElementTemplates(options: DiscoverOptions): Promise<DiscoveryResult>;
+/**
+ * Reads every element template a project holds, wherever it sits.
+ *
+ * The sibling of {@link discoverElementTemplates}, and the opposite walk. That
+ * one answers "which templates apply to this diagram" by climbing from a file
+ * to the root; this one answers "is everything in this project valid" by
+ * descending from the root, which is the question a CI check asks. A project
+ * with templates beside a sub-folder's diagrams would otherwise pass a check
+ * that only ever looked at the root.
+ *
+ * The walk is breadth-first, so templates arrive shallowest-first and a deeper
+ * directory's version of an id registers last and wins. That is a reasonable
+ * merge for a host keeping one registry for a whole project, but it is not the
+ * same thing as per-file resolution: which template a *particular* diagram
+ * should see is {@link discoverElementTemplates}, and only that walk knows.
+ *
+ * @param options - `root` to scan, and the config folder name to look for.
+ */
+export declare function collectElementTemplates(options: {
+    root: string;
+    configFolder?: string;
+}): Promise<DiscoveryResult>;
+//# sourceMappingURL=discover.d.ts.map

package/dist/node/discover.js

@@ -0,0 +1,176 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+import { readTemplateDocument } from "../validate.js";
+/** The folder name searched at each level, unless the caller names another. */
+export const DEFAULT_CONFIG_FOLDER = ".camunda";
+/** The sub-folder inside the config folder that holds templates. */
+export const TEMPLATES_SUBFOLDER = "element-templates";
+/** Directories from `root` down to `from`, so the nearest one is read last. */
+function directoriesFromRootDown(from, root) {
+    const start = resolve(from);
+    if (root === undefined) {
+        // No root given: walk to the filesystem root.
+        const chain = [];
+        for (let dir = start;; dir = dirname(dir)) {
+            chain.push(dir);
+            if (dirname(dir) === dir)
+                break;
+        }
+        return chain.reverse();
+    }
+    const stop = resolve(root);
+    // A start outside the root would otherwise walk past it and out of the
+    // project; search only where the caller said it was allowed to.
+    if (start !== stop && !start.startsWith(stop + sep))
+        return [start];
+    const chain = [];
+    for (let dir = start;; dir = dirname(dir)) {
+        chain.push(dir);
+        if (dir === stop || dirname(dir) === dir)
+            break;
+    }
+    return chain.reverse();
+}
+async function isDirectory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Finds a project's own element templates by convention.
+ *
+ * Every directory from `root` down to the one holding `from` is checked for
+ * `<configFolder>/element-templates/*.json`. No project configuration, no
+ * registration step: drop a template next to the diagram that uses it and the
+ * tools pick it up.
+ *
+ * Order is deliberate. Directories are read root-first so the nearest one is
+ * read last, and `registerElementTemplates` keeps the last registration of an
+ * id — a template beside the diagram overrides one at the project root, which
+ * overrides the bundled catalogue.
+ *
+ * A file that is not valid JSON, or holds a template the schema rejects, is
+ * reported in `problems` against its own path and left out of `templates`. One
+ * bad file never costs the caller the good ones beside it.
+ *
+ * @example
+ * ```typescript
+ * const { templates, problems } = await discoverElementTemplates({
+ *   from: "processes/orders/order.bpmn",
+ *   root: process.cwd(),
+ * });
+ * registerElementTemplates(templates);
+ * ```
+ */
+export async function discoverElementTemplates(options) {
+    const { from, root, configFolder = DEFAULT_CONFIG_FOLDER } = options;
+    // `from` may name the diagram rather than its folder.
+    const startDir = (await isDirectory(from)) ? resolve(from) : dirname(resolve(from));
+    const templates = [];
+    const problems = [];
+    const warnings = [];
+    const directories = [];
+    for (const dir of directoriesFromRootDown(startDir, root)) {
+        const templateDir = join(dir, configFolder, TEMPLATES_SUBFOLDER);
+        if (!(await isDirectory(templateDir)))
+            continue;
+        directories.push(templateDir);
+        const found = await readTemplateDirectory(templateDir);
+        templates.push(...found.templates);
+        problems.push(...found.problems);
+        warnings.push(...found.warnings);
+    }
+    return { templates, problems, warnings, directories };
+}
+/** Reads one `element-templates` directory, in a stable filename order. */
+async function readTemplateDirectory(templateDir) {
+    const templates = [];
+    const problems = [];
+    const warnings = [];
+    const entries = await readdir(templateDir, { withFileTypes: true });
+    const files = entries
+        .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".json"))
+        .map((entry) => entry.name)
+        .sort();
+    for (const name of files) {
+        const file = join(templateDir, name);
+        let parsed;
+        try {
+            parsed = JSON.parse(await readFile(file, "utf-8"));
+        }
+        catch (err) {
+            problems.push({
+                file,
+                path: "",
+                message: `not valid JSON: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            continue;
+        }
+        const result = readTemplateDocument(parsed);
+        templates.push(...result.templates);
+        for (const problem of result.problems)
+            problems.push({ ...problem, file });
+        for (const warning of result.warnings)
+            warnings.push({ ...warning, file });
+    }
+    return { templates, problems, warnings };
+}
+/** Directories never worth descending into when scanning a project. */
+const SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", "out", "coverage"]);
+/**
+ * Reads every element template a project holds, wherever it sits.
+ *
+ * The sibling of {@link discoverElementTemplates}, and the opposite walk. That
+ * one answers "which templates apply to this diagram" by climbing from a file
+ * to the root; this one answers "is everything in this project valid" by
+ * descending from the root, which is the question a CI check asks. A project
+ * with templates beside a sub-folder's diagrams would otherwise pass a check
+ * that only ever looked at the root.
+ *
+ * The walk is breadth-first, so templates arrive shallowest-first and a deeper
+ * directory's version of an id registers last and wins. That is a reasonable
+ * merge for a host keeping one registry for a whole project, but it is not the
+ * same thing as per-file resolution: which template a *particular* diagram
+ * should see is {@link discoverElementTemplates}, and only that walk knows.
+ *
+ * @param options - `root` to scan, and the config folder name to look for.
+ */
+export async function collectElementTemplates(options) {
+    const { root, configFolder = DEFAULT_CONFIG_FOLDER } = options;
+    const templates = [];
+    const problems = [];
+    const warnings = [];
+    const directories = [];
+    const queue = [resolve(root)];
+    while (queue.length > 0) {
+        const dir = queue.shift();
+        if (dir === undefined)
+            continue;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || SKIP_DIRECTORIES.has(entry.name))
+                continue;
+            queue.push(join(dir, entry.name));
+        }
+        const templateDir = join(dir, configFolder, TEMPLATES_SUBFOLDER);
+        if (!(await isDirectory(templateDir)))
+            continue;
+        directories.push(templateDir);
+        const found = await readTemplateDirectory(templateDir);
+        templates.push(...found.templates);
+        problems.push(...found.problems);
+        warnings.push(...found.warnings);
+    }
+    directories.sort();
+    return { templates, problems, warnings, directories };
+}
+//# sourceMappingURL=discover.js.map

package/dist/node/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@bpmnkit/connectors/node` — the filesystem half of element templates.
+ *
+ * Kept behind its own entry point so the main package stays importable in a
+ * browser: a studio or a viewer takes templates from its host and never reaches
+ * for `node:fs`.
+ *
+ * @packageDocumentation
+ */
+export { collectElementTemplates, discoverElementTemplates, DEFAULT_CONFIG_FOLDER, TEMPLATES_SUBFOLDER, } from "./discover.js";
+export type { DiscoverOptions, DiscoveryProblem, DiscoveryResult } from "./discover.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/node/index.js

@@ -0,0 +1,11 @@
+/**
+ * `@bpmnkit/connectors/node` — the filesystem half of element templates.
+ *
+ * Kept behind its own entry point so the main package stays importable in a
+ * browser: a studio or a viewer takes templates from its host and never reaches
+ * for `node:fs`.
+ *
+ * @packageDocumentation
+ */
+export { collectElementTemplates, discoverElementTemplates, DEFAULT_CONFIG_FOLDER, TEMPLATES_SUBFOLDER, } from "./discover.js";
+//# sourceMappingURL=index.js.map

package/dist/template-types.d.ts

@@ -0,0 +1,143 @@
+/**
+ * TypeScript types matching the Camunda element template JSON schema.
+ * https://github.com/camunda/element-templates-json-schema
+ */
+export interface ElementTemplate {
+    /** Unique template identifier (reverse-domain, e.g. "io.camunda.connectors.HttpJson.v2"). */
+    id: string;
+    /** Display name shown in the template catalog. */
+    name: string;
+    /** Short description. */
+    description?: string;
+    /** Integer version; templates with the same id + different version are distinct. */
+    version?: number;
+    /** BPMN element types this template applies to (e.g. "bpmn:ServiceTask", "bpmn:Task"). */
+    appliesTo: string[];
+    /** Forces the element to be converted to this type on apply. */
+    elementType?: {
+        value: string;
+    };
+    /** UI section definitions (collapsible groups). */
+    groups?: TemplateGroup[];
+    /** All property definitions. */
+    properties: TemplateProperty[];
+    /** Link to external documentation. */
+    documentationRef?: string;
+    /** Custom icon: { contents: "data:image/svg+xml;base64,..." } */
+    icon?: {
+        contents: string;
+    };
+}
+export interface TemplateGroup {
+    id: string;
+    label: string;
+    tooltip?: string;
+    openByDefault?: boolean;
+}
+export interface TemplateProperty {
+    /** Unique key used in condition references. Falls back to binding name if absent. */
+    id?: string;
+    /** Label shown above the input. Hidden properties have no label. */
+    label?: string;
+    /** Hint text shown below the input. */
+    description?: string;
+    /** UI control type. */
+    type: "String" | "Text" | "Hidden" | "Dropdown" | "Boolean" | "Number";
+    /** Default value applied when the template is first used. */
+    value?: string | number | boolean;
+    /** Placeholder text. */
+    placeholder?: string;
+    /** If true, empty values are not written to the BPMN XML. */
+    optional?: boolean;
+    /** FEEL expression mode (only relevant for String/Text). */
+    feel?: "optional" | "required" | "static";
+    /** Which template group this property belongs to. */
+    group?: string;
+    /** Tooltip text. */
+    tooltip?: string;
+    /** How this property maps to the BPMN XML. */
+    binding: TemplateBinding;
+    /** Conditional visibility. */
+    condition?: TemplateCondition;
+    /** Required for Dropdown type. */
+    choices?: Array<{
+        name: string;
+        value: string;
+    }>;
+    /** Validation constraints. */
+    constraints?: {
+        notEmpty?: boolean;
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string | {
+            value: string;
+            message: string;
+        };
+    };
+}
+/** All supported binding types. */
+export type TemplateBinding = {
+    type: "property";
+    name: string;
+}
+/** @deprecated Use zeebe:taskDefinition with property field instead. */
+ | {
+    type: "zeebe:taskDefinition:type";
+} | {
+    type: "zeebe:taskDefinition";
+    property: "type" | "retries";
+} | {
+    type: "zeebe:input";
+    name: string;
+} | {
+    type: "zeebe:output";
+    source: string;
+} | {
+    type: "zeebe:taskHeader";
+    key: string;
+} | {
+    type: "zeebe:property";
+    name: string;
+} | {
+    type: "zeebe:adHoc";
+    property: "outputCollection" | "outputElement" | "activeElementsCollection";
+}
+/**
+ * Inbound-connector bindings, and the linked-resource binding used by RPA
+ * templates. The bundled catalogue uses all three, so they belong in the
+ * union — but `applyElementTemplate` does not write them yet, and
+ * `validateElementTemplate` warns when a template depends on one.
+ */
+ | {
+    type: "bpmn:Message#property";
+    name: string;
+} | {
+    type: "bpmn:Message#zeebe:subscription#property";
+    name: string;
+} | {
+    type: "zeebe:linkedResource";
+    property: string;
+    linkName: string;
+};
+/** Condition controlling whether a property is shown in the UI. */
+export type TemplateCondition = {
+    property: string;
+    equals: string;
+    type?: string;
+} | {
+    property: string;
+    oneOf: string[];
+    type?: string;
+} | {
+    property: string;
+    isActive: boolean;
+    type?: string;
+} | {
+    allMatch: Array<{
+        property: string;
+        equals?: string;
+        oneOf?: string[];
+        isActive?: boolean;
+    }>;
+};
+//# sourceMappingURL=template-types.d.ts.map

package/dist/template-types.js

@@ -0,0 +1,6 @@
+/**
+ * TypeScript types matching the Camunda element template JSON schema.
+ * https://github.com/camunda/element-templates-json-schema
+ */
+export {};
+//# sourceMappingURL=template-types.js.map

package/dist/templates/generated.d.ts

@@ -0,0 +1,3 @@
+import type { ElementTemplate } from "../template-types.js";
+export declare const CAMUNDA_CONNECTOR_TEMPLATES: ElementTemplate[];
+//# sourceMappingURL=generated.d.ts.map