@bpmn-ld/bpmn-ld 0.0.0-stage → 0.2.0

package/dist/export/element.js

@@ -0,0 +1,175 @@
+import { CONTAINMENT } from "../convert/mapping.js";
+import { CATCH_EVENTS, childRank, CONTAINS, EXPRESSION_ELEMENTS, MAPPINGS, THROW_EVENTS } from "./data.js";
+export const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export const unsupported = (code, construct, location, owner) => ({
+    kind: "unsupported",
+    code,
+    construct,
+    location,
+    ...(typeof owner?.id === "string" ? { node: owner.id } : {}),
+});
+const SUB_PROCESSES = ["subProcess", "adHocSubProcess", "transaction"];
+const EXCLUDED_FLOW_ELEMENTS = [...SUB_PROCESSES, "laneSet"];
+const PROPERTY_ORDER = ["laneSets"];
+const FLOW_ELEMENTS = Object.keys(CONTAINS.process).filter((name) => !EXCLUDED_FLOW_ELEMENTS.includes(name));
+const EVENT_DEFINITIONS = Object.keys(CONTAINMENT.startEvent);
+const EVENTS = ["startEvent", "endEvent", "intermediateCatchEvent", "intermediateThrowEvent", "boundaryEvent"];
+const ASSOCIATIONS = ["dataInputAssociation", "dataOutputAssociation"];
+const NON_FLOW_NODES = ["sequenceFlow", "association", "laneSet", "dataObject", "dataObjectReference", "dataStoreReference"];
+const FLOW_NODES = [...FLOW_ELEMENTS, ...SUB_PROCESSES].filter((name) => !NON_FLOW_NODES.includes(name));
+const CONTAINER_ELEMENTS = [...FLOW_ELEMENTS, ...SUB_PROCESSES, "laneSet"];
+const ACTIVITY_ELEMENTS = ["task", "businessRuleTask", "manualTask", "receiveTask", "sendTask", "scriptTask", "serviceTask", "userTask"];
+export const SUPPORTED_ELEMENTS = {
+    process: CONTAINER_ELEMENTS,
+    ...Object.fromEntries(SUB_PROCESSES.map((name) => [name, [...CONTAINER_ELEMENTS, ...ASSOCIATIONS]])),
+    ...Object.fromEntries(ACTIVITY_ELEMENTS.map((name) => [name, ASSOCIATIONS])),
+    dataInputAssociation: ["assignment"],
+    dataOutputAssociation: ["assignment"],
+    ioSpecification: ["dataInput", "dataOutput", "inputSet", "outputSet"],
+    laneSet: ["lane"],
+    childLaneSet: ["lane"],
+    collaboration: ["participant", "messageFlow"],
+    ...Object.fromEntries(EVENTS.map((name) => [name, EVENT_DEFINITIONS])),
+    ...Object.fromEntries(THROW_EVENTS.map((name) => [name, [...EVENT_DEFINITIONS, "dataInput", "dataInputAssociation", "inputSet"]])),
+    ...Object.fromEntries(CATCH_EVENTS.map((name) => [name, [...EVENT_DEFINITIONS, "dataOutput", "dataOutputAssociation", "outputSet"]])),
+};
+export const elementName = (type) => {
+    if (typeof type !== "string" || type === "")
+        return undefined;
+    const name = type[0].toLowerCase() + type.slice(1);
+    return MAPPINGS[name]?.type === type ? name : undefined;
+};
+export class ExportContext {
+    warnings = [];
+    roots = {};
+    usedIds;
+    references = new Map();
+    extensions;
+    constructor(usedIds, extensions) {
+        this.usedIds = usedIds;
+        this.extensions = extensions;
+    }
+    reference(root, attribute, value) {
+        const key = `${root}\u0000${value}`;
+        const known = this.references.get(key);
+        if (known !== undefined)
+            return known;
+        let index = this.references.size + 1;
+        let id = `${root[0].toUpperCase()}${root.slice(1)}_${index}`;
+        while (this.usedIds.has(id))
+            id = `${root[0].toUpperCase()}${root.slice(1)}_${++index}`;
+        this.usedIds.add(id);
+        this.references.set(key, id);
+        (this.roots[root] ??= []).push({ "@_id": id, [`@_${attribute}`]: value });
+        return id;
+    }
+}
+export const collectIds = (value, ids = new Set()) => {
+    if (Array.isArray(value))
+        value.forEach((item) => collectIds(item, ids));
+    else if (isObject(value)) {
+        if (typeof value.id === "string")
+            ids.add(value.id);
+        Object.values(value).forEach((item) => collectIds(item, ids));
+    }
+    return ids;
+};
+const connectionsOf = (members) => {
+    const connections = new Map();
+    const entry = (id) => connections.get(id) ?? connections.set(id, { incoming: [], outgoing: [] }).get(id);
+    for (const member of Array.isArray(members) ? members : []) {
+        if (!isObject(member) || member.type !== "SequenceFlow" || typeof member.id !== "string")
+            continue;
+        if (typeof member.sourceRef === "string")
+            entry(member.sourceRef).outgoing.push(member.id);
+        if (typeof member.targetRef === "string")
+            entry(member.targetRef).incoming.push(member.id);
+    }
+    return connections;
+};
+const ordered = (element) => Object.fromEntries(Object.entries(element).sort(([a], [b]) => childRank(a) - childRank(b)));
+const toText = (value) => String(value);
+const exportPartitionElement = (node, location, parent, context) => {
+    const name = elementName(node.type);
+    if (name === undefined) {
+        context.warnings.push(unsupported("unsupported-element", String(node.type), location, node));
+        return;
+    }
+    parent.partitionElement = { ...exportElement(name, node, location, context), "@_xsi:type": `t${node.type}` };
+};
+export const exportElement = (name, node, location, context) => {
+    const mapping = MAPPINGS[name];
+    const element = {};
+    const handled = new Set(["id", "type", "@context"]);
+    for (const [attribute, term] of Object.entries(mapping.attributes)) {
+        handled.add(term);
+        if (node[term] !== undefined)
+            element[`@_${attribute}`] = (mapping.hashPrefixed?.includes(term) ? "##" : "") + toText(node[term]);
+    }
+    for (const lookup of mapping.lookups ?? []) {
+        handled.add(lookup.term);
+        if (node[lookup.term] !== undefined && element[`@_${lookup.attribute}`] === undefined) {
+            element[`@_${lookup.attribute}`] = context.reference(lookup.root, lookup.from, toText(node[lookup.term]));
+        }
+    }
+    for (const [child, term] of Object.entries(mapping.textChildren ?? {})) {
+        handled.add(term);
+        if (node[term] !== undefined)
+            element[child] = toText(node[term]);
+    }
+    for (const [child, term] of Object.entries(mapping.textLists ?? {})) {
+        handled.add(term);
+        if (Array.isArray(node[term]))
+            element[child] = node[term].map(toText);
+        else if (node[term] !== undefined)
+            element[child] = [toText(node[term])];
+    }
+    if (mapping.bodyTerm !== undefined) {
+        handled.add(mapping.bodyTerm);
+        if (node[mapping.bodyTerm] !== undefined)
+            element["#text"] = toText(node[mapping.bodyTerm]);
+    }
+    if (EXPRESSION_ELEMENTS.includes(name)) {
+        element["@_xsi:type"] = "tFormalExpression";
+    }
+    if (name === "conditionalEventDefinition" && !isObject(node.condition))
+        element.condition = { "@_xsi:type": "tFormalExpression" };
+    for (const [child, term] of Object.entries(mapping.singles ?? {})) {
+        handled.add(term);
+        if (!isObject(node[term]))
+            continue;
+        if (child === "partitionElement")
+            exportPartitionElement(node[term], `${location}/${term}`, element, context);
+        else
+            element[child] = exportElement(child, node[term], `${location}/${term}`, context);
+    }
+    const connections = name === "process" || SUB_PROCESSES.includes(name) ? connectionsOf(node.flowElements) : new Map();
+    const allowed = SUPPORTED_ELEMENTS[name] ?? [];
+    const properties = [...new Set(Object.values(CONTAINS[name] ?? {}))].sort((a, b) => Number(!PROPERTY_ORDER.includes(a)) - Number(!PROPERTY_ORDER.includes(b)));
+    for (const property of properties) {
+        handled.add(property);
+        const members = Array.isArray(node[property]) ? node[property] : [];
+        members.forEach((member, index) => {
+            const memberLocation = `${location}/${property}/${index}`;
+            const memberName = elementName(member.type);
+            if (memberName === undefined || !allowed.includes(memberName) || CONTAINS[name][memberName] !== property) {
+                context.warnings.push(unsupported("unsupported-element", String(member.type), memberLocation, member));
+                return;
+            }
+            let exported = exportElement(memberName, member, memberLocation, context);
+            const linked = FLOW_NODES.includes(memberName) && typeof member.id === "string" ? connections.get(member.id) : undefined;
+            if (linked?.incoming.length)
+                exported.incoming = linked.incoming;
+            if (linked?.outgoing.length)
+                exported.outgoing = linked.outgoing;
+            if (linked)
+                exported = ordered(exported);
+            (element[memberName] ??= []).push(exported);
+        });
+    }
+    for (const key of Object.keys(node).sort()) {
+        if (!handled.has(key) && !context.extensions.apply(key, node[key], element))
+            context.warnings.push(unsupported("unsupported-property", key, `${location}/${key}`, node));
+    }
+    return ordered(element);
+};

package/dist/export/export.d.ts

@@ -0,0 +1,22 @@
+import { type ExportWarning } from "./element.ts";
+export type { ExportWarning };
+export interface ExportResult {
+    xml: string;
+    warnings: ExportWarning[];
+}
+export interface ExportOptions {
+    documentUrl?: string;
+}
+export interface ExportError {
+    code: "not-an-object" | "invalid-context" | "invalid-document" | "unreadable-input" | "invalid-json" | "cannot-write" | "strict-mode";
+    location: string;
+    message: string;
+}
+export declare class ExportInputError extends Error {
+    readonly findings: ExportError[];
+    readonly errors: string[];
+    constructor(findings: ExportError[]);
+}
+export declare const schemaFinding: (message: string) => ExportError;
+export declare const ROOT_ELEMENTS: Record<string, string>;
+export declare const exportDocument: (input: unknown, options?: ExportOptions) => Promise<ExportResult>;

package/dist/export/export.js

@@ -0,0 +1,124 @@
+import { XMLBuilder } from "fast-xml-parser";
+import { compileSchema, validateWithSchema } from "../schema-validate.js";
+import { defaultBase } from "../convert/convert.js";
+import { MODEL_NAMESPACE, XSI_NAMESPACE } from "../convert/mapping.js";
+import { DATA_ROOT_ELEMENTS, EVENT_DEFINITION_ROOTS } from "./data.js";
+import { Extensions } from "./extensions.js";
+import { normalize } from "./normalize.js";
+import { DIAGRAM_NAMESPACES, exportDiagram } from "./diagram.js";
+import { collectIds, exportElement, ExportContext, isObject, unsupported } from "./element.js";
+const describe = (error) => `${error.location} ${error.message}`;
+export class ExportInputError extends Error {
+    findings;
+    errors;
+    constructor(findings) {
+        const errors = findings.map(describe);
+        super(`invalid BPMN-LD document: ${errors[0]}`);
+        this.name = "ExportInputError";
+        this.findings = findings;
+        this.errors = errors;
+    }
+}
+export const schemaFinding = (message) => {
+    const split = message.indexOf(" ");
+    return { code: "invalid-document", location: message.slice(0, split), message: message.slice(split + 1) };
+};
+const absolute = (id, base) => {
+    try {
+        return new URL(id, base).href;
+    }
+    catch {
+        return id;
+    }
+};
+export const ROOT_ELEMENTS = { Process: "process", Collaboration: "collaboration", Message: "message", Signal: "signal", Error: "error", Escalation: "escalation", ...EVENT_DEFINITION_ROOTS, ...DATA_ROOT_ELEMENTS };
+const ESCAPES = [
+    [/\r/g, "\uE00D", "
"],
+    [/\n/g, "\uE00A", "
"],
+    [/\t/g, "\uE009", "	"],
+];
+const protect = (value, attribute) => ESCAPES.slice(0, attribute ? 3 : 1).reduce((text, [pattern, sentinel]) => text.replace(pattern, sentinel), value);
+const restore = (xml) => ESCAPES.reduce((text, [, sentinel, entity]) => text.replaceAll(sentinel, entity), xml);
+const toOrdered = (tag, value) => {
+    if (!isObject(value))
+        return [{ [tag]: [{ "#text": protect(String(value), false) }] }];
+    const attributes = {};
+    const children = [];
+    for (const [key, member] of Object.entries(value)) {
+        if (key.startsWith("@_"))
+            attributes[key] = protect(String(member), true);
+        else if (key === "#text")
+            children.push({ "#text": protect(String(member), false) });
+        else if (key === "#children") {
+            for (const child of member) {
+                const [[childTag, childValue]] = Object.entries(child);
+                children.push(...toOrdered(childTag, childValue));
+            }
+        }
+        else if (Array.isArray(member))
+            member.forEach((item) => children.push(...toOrdered(key, item)));
+        else
+            children.push(...toOrdered(key, member));
+    }
+    return [Object.keys(attributes).length > 0 ? { [tag]: children, ":@": attributes } : { [tag]: children }];
+};
+let compiled;
+const schema = () => (compiled ??= compileSchema());
+const unique = (errors) => [...new Set(errors)];
+const targetNamespace = (document) => {
+    const context = Array.isArray(document["@context"]) ? document["@context"] : [document["@context"]];
+    const base = context.find((entry) => isObject(entry) && typeof entry["@base"] === "string");
+    return base?.["@base"] ?? defaultBase();
+};
+export const exportDocument = async (input, options = {}) => {
+    if (!isObject(input))
+        throw new ExportInputError([{ code: "not-an-object", location: "/", message: "document must be a JSON object" }]);
+    let document;
+    try {
+        document = await normalize(input, options.documentUrl);
+    }
+    catch (error) {
+        throw new ExportInputError([{ code: "invalid-context", location: "/@context", message: error.message }]);
+    }
+    const errors = unique(validateWithSchema(document, schema()));
+    if (errors.length > 0)
+        throw new ExportInputError(errors.map(schemaFinding));
+    const context = new ExportContext(collectIds(document), new Extensions(document["@context"], targetNamespace(document)));
+    const { warnings } = context;
+    const graph = Array.isArray(document["@graph"]) ? document["@graph"] : [document];
+    const prefix = Array.isArray(document["@graph"]) ? "/@graph" : "";
+    const definitions = {
+        "@_xmlns": MODEL_NAMESPACE,
+        "@_xmlns:xsi": XSI_NAMESPACE,
+        "@_id": "Definitions_1",
+        "@_targetNamespace": targetNamespace(document),
+    };
+    graph.forEach((root, index) => {
+        const location = prefix === "" ? "" : `${prefix}/${index}`;
+        if (root.type === "BPMNDiagram") {
+            (definitions["bpmndi:BPMNDiagram"] ??= []).push(exportDiagram(root, location, warnings, context.extensions));
+            return;
+        }
+        const name = ROOT_ELEMENTS[root.type];
+        if (name === undefined) {
+            warnings.push(unsupported("unsupported-root", root.type, location || "/", root));
+            return;
+        }
+        (definitions[name] ??= []).push(exportElement(name, root, location, context));
+    });
+    const { process: processes, collaboration: collaborations, "bpmndi:BPMNDiagram": diagrams, ...attributes } = definitions;
+    const generated = Object.fromEntries(Object.entries(context.roots).map(([name, nodes]) => [name, [...(attributes[name] ?? []), ...nodes]]));
+    const ordered = {
+        ...attributes,
+        ...Object.fromEntries([...context.extensions.namespaces].map(([prefix, namespace]) => [`@_xmlns:${prefix}`, namespace])),
+        ...(diagrams ? DIAGRAM_NAMESPACES : {}),
+        ...generated,
+        ...(collaborations ? { collaboration: collaborations } : {}),
+        ...(processes ? { process: processes } : {}),
+        ...(diagrams ? { "bpmndi:BPMNDiagram": diagrams } : {}),
+    };
+    const builder = new XMLBuilder({ preserveOrder: true, ignoreAttributes: false, attributeNamePrefix: "@_", attributesGroupName: ":@", format: true, suppressEmptyNode: true, suppressBooleanAttributes: false });
+    const base = targetNamespace(document);
+    const located = warnings.map((warning) => (warning.node === undefined ? warning : { ...warning, node: absolute(warning.node, base) }));
+    return { xml: `<?xml version="1.0" encoding="UTF-8"?>\n${restore(String(builder.build(toOrdered("definitions", ordered)))).trimStart()}`, warnings: located };
+};

package/dist/export/extensions.d.ts

@@ -0,0 +1,18 @@
+import { type XmlNode } from "./element.ts";
+export declare class Extensions {
+    readonly namespaces: Map<string, string>;
+    private readonly terms;
+    private readonly references;
+    private readonly base;
+    private readonly byNamespace;
+    private generated;
+    constructor(context: unknown, base: string);
+    private expand;
+    private prefixFor;
+    qualify(key: string): string | undefined;
+    private content;
+    private resolve;
+    private scalar;
+    attribute(key: string, value: unknown, element: XmlNode): boolean;
+    apply(key: string, value: unknown, element: XmlNode): boolean;
+}

package/dist/export/extensions.js

@@ -0,0 +1,122 @@
+import { isObject } from "./element.js";
+const RESERVED_PREFIXES = ["xml", "xmlns", "xsi", "dc", "di", "bpmndi"];
+const ABSOLUTE = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+const ABSOLUTE_KEY = /^(?:[A-Za-z][A-Za-z0-9+.-]*:\/\/|urn:)/i;
+const splitIri = (iri) => {
+    const cut = Math.max(iri.lastIndexOf("#"), iri.lastIndexOf("/"), iri.lastIndexOf(":")) + 1;
+    return { namespace: iri.slice(0, cut), local: iri.slice(cut) };
+};
+const isScalar = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+export class Extensions {
+    namespaces = new Map();
+    terms = new Map();
+    references = new Set();
+    base;
+    byNamespace = new Map();
+    generated = 0;
+    constructor(context, base) {
+        this.base = base;
+        const entries = Array.isArray(context) ? context : [context];
+        for (const entry of entries) {
+            if (!isObject(entry))
+                continue;
+            for (const [term, definition] of Object.entries(entry)) {
+                if (term.startsWith("@"))
+                    continue;
+                if (typeof definition === "string")
+                    this.terms.set(term, definition);
+                else if (isObject(definition) && typeof definition["@id"] === "string") {
+                    this.terms.set(term, definition["@id"]);
+                    if (definition["@type"] === "@id")
+                        this.references.add(term);
+                }
+            }
+        }
+    }
+    expand(key, viaTerm = true) {
+        const colon = key.indexOf(":");
+        if (colon > 0) {
+            const prefix = key.slice(0, colon);
+            const namespace = this.terms.get(prefix);
+            if (namespace !== undefined && ABSOLUTE.test(namespace) && !key.startsWith(`${prefix}://`)) {
+                return { namespace, local: key.slice(colon + 1), preferred: prefix };
+            }
+            return ABSOLUTE_KEY.test(key) ? splitIri(key) : undefined;
+        }
+        const target = this.terms.get(key);
+        if (viaTerm && target !== undefined && target !== key)
+            return this.expand(target, false);
+        return undefined;
+    }
+    prefixFor(resolved) {
+        const known = this.byNamespace.get(resolved.namespace);
+        if (known !== undefined)
+            return known;
+        let prefix = resolved.preferred;
+        if (prefix === undefined || RESERVED_PREFIXES.includes(prefix) || this.namespaces.has(prefix)) {
+            do
+                prefix = `ns${++this.generated}`;
+            while (this.namespaces.has(prefix) || this.terms.has(prefix));
+        }
+        this.namespaces.set(prefix, resolved.namespace);
+        this.byNamespace.set(resolved.namespace, prefix);
+        return prefix;
+    }
+    qualify(key) {
+        const resolved = this.expand(key);
+        if (resolved === undefined || resolved.local === "")
+            return undefined;
+        return `${this.prefixFor(resolved)}:${resolved.local}`;
+    }
+    content(value) {
+        if (isScalar(value))
+            return String(value);
+        if (!isObject(value))
+            return undefined;
+        const result = {};
+        for (const [key, member] of Object.entries(value).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) {
+            const name = this.qualify(key);
+            if (name === undefined)
+                continue;
+            const items = (Array.isArray(member) ? member : [member]).map((item) => this.content(item)).filter((item) => item !== undefined);
+            if (items.length > 0)
+                result[name] = items;
+        }
+        return result;
+    }
+    resolve(reference) {
+        try {
+            return new URL(reference, this.base).href;
+        }
+        catch {
+            return reference;
+        }
+    }
+    scalar(key, value) {
+        const reference = isObject(value) && Object.keys(value).length === 1 && typeof value.id === "string" ? value.id : value;
+        if (!isScalar(reference))
+            return undefined;
+        return typeof reference === "string" && this.references.has(key) ? this.resolve(reference) : String(reference);
+    }
+    attribute(key, value, element) {
+        const name = this.qualify(key);
+        const text = this.scalar(key, value);
+        if (name === undefined || text === undefined)
+            return false;
+        element[`@_${name}`] = text;
+        return true;
+    }
+    apply(key, value, element) {
+        const name = this.qualify(key);
+        if (name === undefined)
+            return false;
+        if (this.attribute(key, value, element))
+            return true;
+        const items = (Array.isArray(value) ? value : [value]).map((item) => this.content(item)).filter((item) => item !== undefined);
+        if (items.length === 0)
+            return true;
+        const container = (element.extensionElements ??= {});
+        container[name] = [...(container[name] ?? []), ...items];
+        return true;
+    }
+}

package/dist/export/layout-export.d.ts

@@ -0,0 +1,4 @@
+import { type LayoutOptions } from "../layout/layout.ts";
+import { type ExportOptions, type ExportResult } from "./export.ts";
+export type LayoutAndExportOptions = ExportOptions & LayoutOptions;
+export declare const layoutAndExport: (input: unknown, options?: LayoutAndExportOptions) => Promise<ExportResult>;

package/dist/export/layout-export.js

@@ -0,0 +1,25 @@
+import { layoutDocument, LayoutInputError } from "../layout/layout.js";
+import { exportDocument, ExportInputError, schemaFinding } from "./export.js";
+import { isObject } from "./element.js";
+import { normalize } from "./normalize.js";
+export const layoutAndExport = async (input, options = {}) => {
+    if (!isObject(input))
+        return exportDocument(input, options);
+    let document;
+    try {
+        document = await normalize(input, options.documentUrl);
+    }
+    catch (error) {
+        throw new ExportInputError([{ code: "invalid-context", location: "/@context", message: error.message }]);
+    }
+    let laidOut;
+    try {
+        laidOut = layoutDocument(document, { force: options.force }).document;
+    }
+    catch (error) {
+        if (error instanceof LayoutInputError)
+            throw new ExportInputError(error.errors.map(schemaFinding));
+        throw error;
+    }
+    return exportDocument(laidOut, { documentUrl: options.documentUrl });
+};

package/dist/export/mapping-check.d.ts

@@ -0,0 +1,39 @@
+import type { Store } from "n3";
+import { type ElementMapping } from "../convert/mapping.ts";
+export interface ConverterTables {
+    elements: Record<string, ElementMapping>;
+    containment: Record<string, Record<string, string>>;
+    roots: string[];
+    diagramElements: string[];
+}
+export interface ExporterTables {
+    elements: Record<string, ElementMapping>;
+    containment: Record<string, Record<string, string>>;
+    supported: Record<string, string[]>;
+    diagram: Record<string, {
+        attributes: string[];
+        children: string[];
+    }>;
+    roots: string[];
+}
+export interface AllowedDifference {
+    where: string;
+    reason: string;
+}
+export type ExportMappingReason = "not-in-context" | "not-in-ontology" | "not-exported" | "export-only" | "term-mismatch" | "type-mismatch" | "not-supported" | "stale-allowance";
+export interface ExportMappingProblem {
+    where: string;
+    reason: ExportMappingReason;
+    detail: string;
+}
+export interface ExportMappingInput {
+    exporter: ExporterTables;
+    converter: ConverterTables;
+    store: Store;
+    context: Record<string, string>;
+    allowed?: AllowedDifference[];
+}
+export declare const converterTables: () => ConverterTables;
+export declare const exporterTables: () => ExporterTables;
+export declare const ALLOWED_DIFFERENCES: AllowedDifference[];
+export declare const checkExportMapping: ({ exporter, converter, store, context, allowed }: ExportMappingInput) => ExportMappingProblem[];