@codenotch/codenotch.react 1.0.81

package/dist/index.js

@@ -0,0 +1,370 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeEditor = exports.env = void 0;
+exports.useCodenotch = useCodenotch;
+exports.init = init;
+const react_dom_1 = __importDefault(require("react-dom"));
+const SignalR_1 = require("./core/SignalR");
+const ProcessUtils_1 = __importDefault(require("./core/ProcessUtils"));
+const uuid_1 = require("uuid");
+const CodeEditor_1 = __importDefault(require("./components/CodeEditor"));
+exports.CodeEditor = CodeEditor_1.default;
+var signalR = undefined;
+/**
+ * The Codenotch runtime environment, populated by {@link init}.
+ * Prefer reading it through `useCodenotch().env`.
+ */
+const env = {};
+exports.env = env;
+const MISSING_CLUSTER_URL_ERROR = "Codenotch cluster URL is not defined. Please set it in the Codenotch configuration.";
+const MISSING_SERVICE_NAME_ERROR = "Codenotch service name is not defined. Please set it in the Codenotch configuration.";
+const MISSING_TENANT_NAME_ERROR = "Codenotch tenant name is not defined. Please set it in the Codenotch configuration.";
+/**
+ * Initialize the Codenotch environment from the given key-value pairs.
+ *
+ * This is normally called once, by the page hosting the application, with the
+ * environment variables injected by the Codenotch runtime (URL parameters or
+ * any other source). It must be called before `useCodenotch()` is used.
+ *
+ * Recognized key formats:
+ * - `i18n.<key>.<language>` — a translation, stored in `env.i18n[language][key]`.
+ *   The first language found becomes the current language if none is set.
+ * - `GLOBAL.<name>` — JSON value assigned to `window[name]` (or `globalThis`).
+ * - `appManifest` / `projectManifest` — parsed as JSON into the environment.
+ * - anything else — copied as-is onto {@link env}.
+ *
+ * The UI theme is resolved from the `_theme` URL parameter, or from
+ * `prefers-color-scheme` as a fallback.
+ *
+ * @param envVariables An object containing the Codenotch environment variables as key-value pairs.
+ * @example
+ * import { init } from 'codenotch-react';
+ * init({
+ *     clusterUrl: 'https://cluster.example.com',
+ *     serviceName: 'myproject',
+ *     tenantName: 'acme',
+ *     'i18n.welcome.en': 'Welcome',
+ *     'i18n.welcome.fr': 'Bienvenue'
+ * });
+ */
+function init(envVariables) {
+    // Ensure envVariables is an object
+    if (typeof envVariables === 'object' && envVariables !== null) {
+        let i18nLanguages = new Set();
+        Object.keys(envVariables).forEach((key) => {
+            try {
+                if (key.startsWith('GLOBAL.')) {
+                    // Global variable, we set it directly on the window object
+                    let globalKey = key.substring('GLOBAL.'.length);
+                    let globalObject = typeof window !== 'undefined' ? window : globalThis;
+                    globalObject[globalKey] = JSON.parse(envVariables[key]);
+                    console.log(`Codenotch global variable ${globalKey} set!`);
+                    return;
+                }
+                else if (key.startsWith("i18n.")) {
+                    // Special case
+                    let parts = key.split("."); // i18n.someKey.fr
+                    let language = parts[parts.length - 1]; // fr
+                    let keyName = parts.slice(1, parts.length - 1).join("."); // someKey
+                    i18nLanguages.add(language);
+                    let value = `${envVariables[key]}`.trim();
+                    if (value.startsWith('"') && value.endsWith('"')) {
+                        // Parse like json
+                        value = JSON.parse(value);
+                    }
+                    env.i18n = env.i18n ?? {};
+                    env.i18n[language] = env.i18n[language] ?? {};
+                    env.i18n[language][keyName] = value;
+                }
+                else {
+                    env[key] = envVariables[key];
+                    if (['appManifest', 'projectManifest'].includes(key)) {
+                        // Must be Json
+                        try {
+                            env[key] = JSON.parse(envVariables[key]);
+                        }
+                        catch (error) {
+                            console.warn(`Codenotch environment variable ${key} is not a valid JSON string. Using raw value.`);
+                        }
+                    }
+                    console.log(`Codenotch environment variable ${key} set to ${env[key]}`);
+                }
+            }
+            catch (error) {
+                console.error(`Error processing Codenotch environment variable ${key}:`, error);
+            }
+        });
+        if (env.language === undefined) {
+            // If current language is not defined, we set it to the first language found in i18n
+            if (i18nLanguages.size > 0) {
+                env.language = Array.from(i18nLanguages)[0];
+                console.log(`Codenotch current language set to ${env.language}`);
+            }
+        }
+    }
+    // Instantiate SignalR for further use in the API
+    if (env.clusterUrl && env.serviceName) {
+        signalR = new SignalR_1.SignalR(env.clusterUrl, env.serviceName, false, env.accessToken);
+    }
+    // Get theme like AEC does
+    try {
+        let urlParams = Object.fromEntries(new URLSearchParams(window.location.search).entries());
+        if (urlParams["_theme"]) {
+            let theme = urlParams["_theme"].toLowerCase();
+            if (theme === "light" || theme === "dark") {
+                env.theme = theme;
+            }
+        }
+        else if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) {
+            env.theme = 'dark';
+        }
+        else {
+            env.theme = 'light';
+        }
+    }
+    catch {
+    }
+}
+/**
+ * Return the Codenotch client API bound to the current environment.
+ *
+ * Despite its name this is NOT a React hook — it is a plain function with no
+ * hook rules attached: it can be called anywhere (components, handlers, plain
+ * modules). `init()` must have been called first, which the Codenotch runtime
+ * does automatically when serving the application.
+ *
+ * @returns The Codenotch API: BPMN processes, SioQL queries, i18n, signals, theme…
+ * @example
+ * import { useCodenotch } from 'codenotch-react';
+ *
+ * const MyApp: React.FC = () => {
+ *     const cn = useCodenotch();
+ *     return <h1>{cn.i18n('welcome')}</h1>;
+ * };
+ */
+function useCodenotch() {
+    return {
+        env: env,
+        uuid: () => (0, uuid_1.v4)(),
+        getProjectFileUrl: (relativePath) => {
+            if (env.clusterUrl === undefined)
+                throw new Error(MISSING_CLUSTER_URL_ERROR);
+            if (env.serviceName === undefined)
+                throw new Error(MISSING_SERVICE_NAME_ERROR);
+            relativePath = relativePath.replace(/\\/g, "/");
+            if (relativePath.startsWith("/"))
+                relativePath = relativePath.substring(1);
+            let url = `${env.clusterUrl}/${env.serviceName}/project/file?name=""&path=${encodeURIComponent(relativePath)}`;
+            return url;
+        },
+        getProjectFile: async (relativePath) => {
+            let url = useCodenotch().getProjectFileUrl(relativePath);
+            let resp = await fetch(url);
+            if (resp.status.toString().startsWith('2') === false) {
+                throw new Error(`Failed to fetch file content: ${resp.status} ${resp.statusText}`);
+            }
+            let content = await resp.text();
+            return content;
+        },
+        requestSioql: async (sioql, verbose) => {
+            if (env.clusterUrl === undefined)
+                throw new Error(MISSING_CLUSTER_URL_ERROR);
+            if (env.serviceName === undefined)
+                throw new Error(MISSING_SERVICE_NAME_ERROR);
+            const request = {
+                method: 'POST',
+                mode: 'cors',
+                credentials: 'same-origin',
+                headers: { 'Content-Type': 'application/json' },
+                body: `"${sioql.replace(/\"/g, '\\\"')}"`
+            };
+            if (`${env.accessToken ?? ''}`.trim() !== "") {
+                if (env.tenantName === undefined)
+                    throw new Error(MISSING_TENANT_NAME_ERROR);
+                request.headers = {
+                    ...request.headers, [`${env.tenantName}AccessToken`]: env.accessToken
+                };
+            }
+            const response = await fetch(`${env.clusterUrl}/${env.serviceName}/sioql${verbose ? "?v=true" : ""}`, request);
+            if (!response.ok) {
+                const error = await response.text();
+                throw new Error(error);
+            }
+            return await response.json();
+        },
+        i18n: (key, ...args) => {
+            try {
+                if (env.i18n === undefined || Object.keys(env.i18n).length === 0) {
+                    console.warn("Codenotch i18n is not defined. Please set it in the Codenotch configuration.");
+                    return key;
+                }
+                let language = env.language ?? "en";
+                let isLanguageExists = env.i18n[language] !== undefined;
+                if (isLanguageExists === false) {
+                    let fallbackLanguage = Object.keys(env.i18n)[0];
+                    console.warn(`Codenotch i18n language ${language} is not defined. Falling back to ${fallbackLanguage}. Please set the correct language in the Codenotch configuration.`);
+                    language = fallbackLanguage;
+                }
+                let dico = env.i18n[language];
+                let value = dico[key];
+                if (typeof value !== "string") {
+                    console.warn(`Codenotch i18n key ${key} is not defined for language ${language}. Please set it in the Codenotch configuration.`);
+                    return key;
+                }
+                args = args ?? [];
+                let result = value.replace(/{([\d ]*)}/g, (match, p1) => {
+                    let argValue = args[p1.trim()];
+                    // Instead of returning 'undefined', returns an empty string
+                    return argValue !== undefined ? argValue : "";
+                });
+                return result;
+            }
+            catch (error) {
+                console.error("Error in i18n function:", error);
+                return key;
+            }
+        },
+        startProcess: async (processName, startNodeId, inputs) => {
+            if (env.clusterUrl === undefined)
+                throw new Error(MISSING_CLUSTER_URL_ERROR);
+            if (env.serviceName === undefined)
+                throw new Error(MISSING_SERVICE_NAME_ERROR);
+            if (env.tenantName === undefined)
+                throw new Error(MISSING_TENANT_NAME_ERROR);
+            if (signalR === undefined)
+                throw new Error("SignalR not available. Cannot start process.");
+            return ProcessUtils_1.default.startProcess((processInstanceId, callbacks) => signalR.subscribeToProcessInstance(processInstanceId, callbacks), env.clusterUrl, env.tenantName, env.serviceName, processName, inputs, undefined, startNodeId ?? 'start', env.accessToken);
+        },
+        getUrlParams: () => {
+            let result = {};
+            if (typeof window !== 'undefined') {
+                const params = new URL(window.location.href).searchParams;
+                params.forEach((value, key) => {
+                    if (result[key] === undefined) {
+                        result[key] = value;
+                    }
+                });
+            }
+            return result;
+        },
+        showDialog: (node) => {
+            let dialogId = "codenotch-dialog-" + Math.random().toString(36).substring(2, 9);
+            let result = {
+                id: dialogId,
+                close: () => {
+                    let dialogElement = document.getElementById(dialogId);
+                    if (dialogElement) {
+                        dialogElement.remove();
+                    }
+                }
+            };
+            // Find "cn-dialog-container" element in the page
+            let container = document.getElementById("cn-dialog-container");
+            if (container === null) {
+                container = document.createElement("div");
+                container.id = "cn-dialog-container";
+                container.style.zIndex = "9999";
+                container.style.position = "fixed";
+                container.style.top = "0";
+                container.style.left = "0";
+                container.style.minWidth = "100vw";
+                container.style.minHeight = "100vh";
+                container.style.maxWidth = "100vw";
+                container.style.maxHeight = "100vh";
+                container.style.display = "flex";
+                container.style.alignItems = "center";
+                container.style.justifyContent = "center";
+                container.style.pointerEvents = 'none';
+                document.body.appendChild(container);
+            }
+            let dialogElement = document.createElement('dialog');
+            dialogElement.id = dialogId;
+            dialogElement.style.zIndex = "9999";
+            dialogElement.style.position = "fixed";
+            dialogElement.style.top = "0";
+            dialogElement.style.left = "0";
+            dialogElement.style.minWidth = "100vw";
+            dialogElement.style.minHeight = "100vh";
+            dialogElement.style.maxWidth = "100vw";
+            dialogElement.style.maxHeight = "100vh";
+            dialogElement.style.display = "flex";
+            dialogElement.style.alignItems = "center";
+            dialogElement.style.justifyContent = "center";
+            dialogElement.style.pointerEvents = 'all';
+            dialogElement.style.background = '#78787822';
+            dialogElement.style.backdropFilter = 'blur(2px)';
+            container.appendChild(dialogElement);
+            react_dom_1.default.render(node, dialogElement, () => {
+                dialogElement.showModal();
+            });
+            return result;
+        },
+        listenSignal: async (signalId, callback) => {
+            if (!signalR) {
+                throw new Error("SignalR not available. Cannot listen to signal.");
+            }
+            let unsubscribeFunc = await signalR.subscribeToSignal(signalId, callback);
+            return {
+                dispose: () => {
+                    unsubscribeFunc();
+                }
+            };
+        },
+        setTheme: (theme) => {
+            if (env.theme === theme)
+                return;
+            if (env.theme)
+                document.documentElement.classList.remove(env.theme);
+            env.theme = theme;
+            document.documentElement.classList.add(theme);
+        },
+        setLanguage: (lang) => {
+            if (env.language === lang)
+                return;
+            env.language = lang;
+        },
+        getLanguages: () => {
+            return env.projectManifest?.languages ?? [];
+        },
+        getLanguage: () => {
+            return env.language;
+        },
+        getTheme: () => {
+            return env.theme;
+        },
+        getProjectManifest: () => {
+            if (env.projectManifest === undefined) {
+                throw new Error("Project manifest is not defined in Codenotch environment. Please set it in the Codenotch configuration.");
+            }
+            return env.projectManifest;
+        },
+        getAppManifest: () => {
+            return env.appManifest;
+        }
+    };
+}
+// Public models. Re-exported from the package root so that the typings
+// generated by the Codenotch IDE (typings/i18n.d.ts and typings/process.d.ts,
+// which augment the 'codenotch-react' module) merge with the real
+// TranslationRegistry / ProcessRegistry declarations.
+__exportStar(require("./models/Codenotch"), exports);
+__exportStar(require("./models/Misc"), exports);
+__exportStar(require("./models/AppManifestModels"), exports);
+__exportStar(require("@codenotch/codenotch.core"), exports);

package/dist/models/AppManifestModels.d.ts

@@ -0,0 +1,46 @@
+export interface ApplicationManifest {
+    pwa?: PWAManifest;
+    html?: HTMLManifest;
+    auml?: AUMLManifest;
+}
+export interface HTMLManifest {
+    title?: string;
+    description?: string;
+    author?: string;
+    keywords?: string;
+    charset?: string;
+}
+export interface PWAManifest {
+    background_color?: string;
+    description?: string;
+    dir?: string;
+    display?: string;
+    icons?: PWAManifestIcon[];
+    lang?: string;
+    name?: string;
+    orientation?: string;
+    prefer_related_applications?: boolean;
+    related_applications?: PWAManifestRelatedApplications[];
+    scope?: string;
+    short_name?: string;
+    start_url?: string;
+    theme_color?: string;
+    shortcuts?: string;
+    display_override?: string[];
+}
+export interface PWAManifestIcon {
+    src?: string;
+    sizes?: string;
+    type?: string;
+}
+export interface PWAManifestRelatedApplications {
+    platform?: string;
+    url?: string;
+    id?: string;
+}
+export interface AUMLManifest {
+    name?: string;
+    description?: string;
+    logoURL?: string;
+}
+//# sourceMappingURL=AppManifestModels.d.ts.map

package/dist/models/AppManifestModels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppManifestModels.d.ts","sourceRoot":"","sources":["../../src/models/AppManifestModels.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,mBAAmB;IAChC,GAAG,CAAC,EAAE,WAAW,CAAC;IAElB,IAAI,CAAC,EAAE,YAAY,CAAC;IAEpB,IAAI,CAAC,EAAE,YAAY,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,eAAe,EAAE,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC,oBAAoB,CAAC,EAAE,8BAA8B,EAAE,CAAC;IACxD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,8BAA8B;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/dist/models/AppManifestModels.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/Codenotch.d.ts

@@ -0,0 +1,256 @@
+import { ProjectManifest } from "@codenotch/codenotch.core";
+import { ICodenotchSignal, IDisposable } from "./Misc";
+import { ApplicationManifest } from "./AppManifestModels";
+/**
+ * Runtime environment of a Codenotch application.
+ *
+ * Populated by `init()` from the environment variables injected by the Codenotch
+ * runtime into the hosting page, and exposed read-only through {@link ICodenotchApi.env}.
+ */
+export interface ICodenotchEnv {
+    /** Name of the current application. */
+    appName?: string;
+    /** Base URL of the Codenotch cluster hosting the project, e.g. `https://cluster.example.com`. */
+    clusterUrl?: string;
+    /** Service name of the project (`serviceName` in the project's `manifest.json`). Used to build every server URL. */
+    serviceName?: string;
+    /** Name of the tenant hosting the project. Required when authenticating with an access token. */
+    tenantName?: string;
+    /** Access token used to authenticate server calls, sent as the `<tenantName>AccessToken` HTTP header. */
+    accessToken?: string;
+    /** Base URL of the current application. */
+    baseUrl?: string;
+    /** Translation dictionaries, keyed by language then by translation key: `i18n[language][key] = text`. */
+    i18n?: {
+        [language: string]: {
+            [key: string]: string;
+        };
+    };
+    /** Current language code (e.g. `"en"`). Defaults to the first language found in {@link i18n}. */
+    language?: string;
+    /** Current UI theme. Resolved from the `_theme` URL parameter, or `prefers-color-scheme` as a fallback. */
+    theme?: 'light' | 'dark';
+    /** Manifest of the current application (the `<AppName>.manifest.json` file next to the app). */
+    appManifest?: ApplicationManifest;
+    /** Manifest of the Codenotch project (the project's `manifest.json` file). */
+    projectManifest?: ProjectManifest;
+    /** Any additional environment variable passed to `init()`. */
+    [key: string]: any;
+}
+/**
+ * Registry of the project's BPMN processes, used to type {@link ICodenotchApi.startProcess}.
+ *
+ * Empty by default: the Codenotch IDE fills it through declaration merging in the
+ * auto-generated `typings/process.d.ts` file of each project, with one entry per
+ * BPMN process. Each entry maps the process name to its start events (`nodes`,
+ * keyed by start node id, valued with the start event's input parameters) and to
+ * the `output` of its end event.
+ *
+ * When the registry has not been augmented (project built without the IDE
+ * typings), `startProcess` falls back to plain string names and untyped inputs,
+ * so the code still compiles.
+ *
+ * @example
+ * // typings/process.d.ts (auto-generated by the Codenotch IDE)
+ * import 'codenotch-react';
+ * declare module 'codenotch-react' {
+ *     interface ProcessRegistry {
+ *         'getTodos': {
+ *             nodes: { 'start': { UserId: string } };
+ *             output: { todos: any[] };
+ *         };
+ *     }
+ * }
+ */
+export interface ProcessRegistry {
+}
+/**
+ * Registry of the project's translation keys, used to type {@link ICodenotchApi.i18n}.
+ *
+ * Empty by default: the Codenotch IDE fills it through declaration merging in the
+ * auto-generated `typings/i18n.d.ts` file of each project, from the project's
+ * `.i18n.csv` files. Each entry maps a translation key to the tuple of arguments
+ * expected by its `{0}`, `{1}`, … placeholders.
+ *
+ * When the registry has not been augmented (project built without the IDE
+ * typings), `i18n` falls back to plain string keys and untyped arguments,
+ * so the code still compiles.
+ *
+ * @example
+ * // typings/i18n.d.ts (auto-generated by the Codenotch IDE)
+ * import 'codenotch-react';
+ * declare module 'codenotch-react' {
+ *     interface TranslationRegistry {
+ *         'welcome': [];
+ *         'greeting': [arg1: any, arg2: any];
+ *     }
+ * }
+ */
+export interface TranslationRegistry {
+}
+/** A BPMN process name: a key of {@link ProcessRegistry}, or any string when the registry is empty. */
+export type ProcessName = keyof ProcessRegistry extends never ? string : keyof ProcessRegistry;
+/** The start nodes of process `P`: its `nodes` map from {@link ProcessRegistry}, or an open map when unknown. */
+export type ProcessNodes<P> = P extends keyof ProcessRegistry ? ProcessRegistry[P] extends {
+    nodes: infer N;
+} ? N : {
+    [nodeId: string]: any;
+} : {
+    [nodeId: string]: any;
+};
+/** The end-event output of process `P` from {@link ProcessRegistry}, or `any` when unknown. */
+export type ProcessOutput<P> = P extends keyof ProcessRegistry ? ProcessRegistry[P] extends {
+    output: infer O;
+} ? O : any : any;
+/** A translation key: a key of {@link TranslationRegistry}, or any string when the registry is empty. */
+export type TranslationKey = keyof TranslationRegistry extends never ? string : keyof TranslationRegistry;
+/** The placeholder arguments of translation key `K` from {@link TranslationRegistry}, or `any[]` when unknown. */
+export type TranslationArgs<K> = K extends keyof TranslationRegistry ? TranslationRegistry[K] extends any[] ? TranslationRegistry[K] : any[] : any[];
+/**
+ * Result of a BPMN process execution started with {@link ICodenotchApi.startProcess}.
+ */
+export interface IProcessResult<T = any> {
+    /** Unique id of this execution of the process. */
+    processInstanceId: string;
+    /** Output parameters of the end event reached by the process. */
+    output: T;
+    /** `true` if the process ended in error; check it before reading {@link output}. */
+    isError: boolean;
+    /** Error details when {@link isError} is `true`. */
+    errorMessage: string;
+}
+/**
+ * The Codenotch client API, obtained by calling `useCodenotch()`.
+ *
+ * It is the bridge between a React app and the Codenotch runtime: it starts
+ * server-side BPMN processes, runs SioQL queries, translates i18n keys,
+ * listens to real-time signals and manages theme/language.
+ *
+ * @example
+ * import { useCodenotch } from 'codenotch-react';
+ *
+ * const cn = useCodenotch();
+ * const title = cn.i18n('welcome');
+ * const result = await cn.startProcess('getTodos', 'start', { UserId: '42' });
+ */
+export interface ICodenotchApi {
+    /**
+     * Start a server-side BPMN process and wait for its completion.
+     *
+     * @param processName Name of the process — the `.bpmn` file name without extension (e.g. `processes/getTodos.bpmn` → `'getTodos'`).
+     * @param startNodeId Id of the start event to trigger (conventionally `'start'`).
+     * @param inputs Input parameters declared by that start event.
+     * @returns The process result; check `isError` before using `output` (the parameters of the end event reached).
+     * @example
+     * const result = await cn.startProcess('getTodos', 'start', { UserId: userId });
+     * if (!result.isError) {
+     *     setTodos(result.output.todos);
+     * }
+     */
+    startProcess<P extends ProcessName, N extends keyof ProcessNodes<P>>(processName: P, startNodeId: N, inputs: ProcessNodes<P>[N]): Promise<IProcessResult<ProcessOutput<P>>>;
+    /**
+     * Translate a key for the current language ({@link ICodenotchEnv.language}).
+     *
+     * Placeholders `{0}`, `{1}`, … in the translated text are replaced by `args`.
+     * Never throws: if the key or the language is missing, a warning is logged
+     * and the key itself is returned.
+     *
+     * @param key Translation key, as defined in the project's `.i18n.csv` files.
+     * @param args Values for the `{0}`, `{1}`, … placeholders of the translation.
+     * @example
+     * cn.i18n('welcome');                    // "Bienvenue"
+     * cn.i18n('greeting', 'Fabian', 3);      // "Bonjour Fabian, 3 messages" (from "Bonjour {0}, {1} messages")
+     */
+    i18n<K extends TranslationKey>(key: K, ...args: TranslationArgs<K>): string;
+    /** Runtime environment (cluster, service, language, theme, i18n dictionaries, manifests…). Populated by `init()`. */
+    readonly env: ICodenotchEnv;
+    /**
+     * Execute a SioQL query (XML, SELECT-only) against the project's SQL tables and return the parsed JSON result.
+     *
+     * The root element's `xmlns` must be the project's `serviceName`. Results are
+     * keyed by the `Ref` attribute of each queried table.
+     *
+     * @param sioql The SioQL XML query.
+     * @param verbose When `true`, asks the server for a verbose response (debugging).
+     * @example
+     * const data = await cn.requestSioql(`
+     *     <SioQL xmlns="myproject" PageSize="10" PageIndex="0">
+     *         <Users Ref="results">
+     *             <Id />
+     *             <Email />
+     *         </Users>
+     *     </SioQL>`);
+     * console.log(data.results); // [{ Id: ..., Email: ... }, ...]
+     */
+    readonly requestSioql: (sioql: string, verbose?: boolean) => Promise<any>;
+    /**
+     * Render the given React element in a fullscreen modal `<dialog>` overlay.
+     *
+     * The dialog is not closed automatically: keep the returned handle and call
+     * its `close()` method (typically from a button inside the dialog content).
+     *
+     * @example
+     * const dialog = cn.showDialog(
+     *     <div className="bg-white p-4 rounded">
+     *         <p>Are you sure?</p>
+     *         <button onClick={() => dialog.close()}>Close</button>
+     *     </div>
+     * );
+     */
+    readonly showDialog: (node: JSX.Element) => ICodenotchDialog;
+    /**
+     * Fetch the text content of a file of the deployed Codenotch project.
+     * @param relativePath Path of the file relative to the project root (e.g. `'readme.md'`).
+     */
+    readonly getProjectFile: (relativePath: string) => Promise<string | undefined>;
+    /**
+     * Build the URL serving a file of the deployed Codenotch project
+     * (useful as `src` for images or links).
+     * @param relativePath Path of the file relative to the project root.
+     */
+    readonly getProjectFileUrl: (relativePath: string) => string;
+    /**
+     * Subscribe to a real-time signal emitted by the project's BPMN processes (via SignalR).
+     *
+     * @param signalId Id of the signal, as declared in the BPMN process.
+     * @param callback Called each time the signal is received, with `{ signalId, data }`.
+     * @returns A disposable — call `dispose()` to unsubscribe (e.g. in a `useEffect` cleanup).
+     * @example
+     * useEffect(() => {
+     *     let sub: IDisposable | undefined;
+     *     cn.listenSignal('todosChanged', () => refresh()).then(s => sub = s);
+     *     return () => sub?.dispose();
+     * }, []);
+     */
+    readonly listenSignal: (signalId: string, callback: (data: ICodenotchSignal) => void) => Promise<IDisposable>;
+    /** Set the UI theme. Also toggles the `light`/`dark` class on `<html>` (Tailwind `dark:` variants). */
+    readonly setTheme: (theme: 'light' | 'dark') => void;
+    /** Current UI theme, if resolved. */
+    readonly getTheme: () => 'light' | 'dark' | undefined;
+    /** Set the current language used by {@link i18n}. Must be one of the project's languages. */
+    readonly setLanguage: (lang: string) => void;
+    /** Current language code, if any. */
+    readonly getLanguage: () => string | undefined;
+    /** Languages declared in the project's `manifest.json`. */
+    readonly getLanguages: () => string[];
+    /** Query-string parameters of the current URL, as a plain object (first value wins for duplicated keys). */
+    readonly getUrlParams: () => {
+        [key: string]: string;
+    };
+    /** Generate a random UUID v4. */
+    readonly uuid: () => string;
+    /** Manifest of the Codenotch project. Throws if not available in the environment. */
+    readonly getProjectManifest: () => ProjectManifest;
+    /** Manifest of the current application, if any. */
+    readonly getAppManifest: () => ApplicationManifest | undefined;
+}
+/**
+ * Handle on a dialog opened with {@link ICodenotchApi.showDialog}.
+ */
+export interface ICodenotchDialog {
+    /** DOM id of the underlying `<dialog>` element. */
+    id: string;
+    /** Close the dialog and remove it from the DOM. */
+    close: () => void;
+}
+//# sourceMappingURL=Codenotch.d.ts.map