@sap-ux/ui5-test-writer 1.1.13 → 1.2.0

package/dist/translations/ui5-test-writer.i18n.json

@@ -6,5 +6,15 @@
         "cannotGeneratePageFile": "Cannot generate the page file for target: {{ targetKey }}.",
         "errorCopyingFreestyleTestTemplates": "An error occurred when copying freestyle test templates: {{ error }}",
         "errorWritingTsConfig": "An error occurred when writing the `tsconfig.json` file: {{ error }}"
+    },
+    "warn": {
+        "cannotUpdateJourneyRunner": "Could not update `JourneyRunner.js`. The existing file may be missing or unreadable. New pages were not registered.",
+        "cannotUpdateOpaTestsQunit": "Could not update `opaTests.qunit.js`. The existing file may be missing or unreadable. New journey paths were not registered.",
+        "cannotUpdateOpaJourneyTypes": "Could not update `OpaJourneyTypes.d.ts`. The existing file may be missing or unreadable. New journey type definitions were not registered."
+    },
+    "info": {
+        "opaJourneyTypesNotUpdated": "`OpaJourneyTypes.d.ts` was not updated due to an incompatible existing test setup.",
+        "incompatibleTestSetupSkipped": "`testsuite.qunit` and `opaTests.qunit` files were not updated due to an incompatible existing test setup.",
+        "manualIntegrationRequired": "Please ensure the generated journeys and pages are integrated into your existing OPA5 test setup."
     }
 }

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import type { Editor } from 'mem-fs-editor';
+import type { Logger } from '@sap-ux/logger';
 export declare const DotFileExtension: {
     readonly JS: ".js";
     readonly TS: ".ts";
@@ -31,6 +32,8 @@ export type FEV4OPAPageConfig = {
     contextPath?: string;
     targetKey: string;
     isStartup: boolean;
+    fileName?: string;
+    fileExtension?: string;
 };
 export type FEV4OPAConfig = {
     appID: string;
@@ -40,6 +43,7 @@ export type FEV4OPAConfig = {
     htmlTarget: string;
     hideFilterBar: boolean;
     filterBarItems?: string[];
+    useVirtualPreviewEndpoints: boolean;
 };
 export type JourneyParams = {
     startPages: string[];
@@ -209,11 +213,17 @@ export type AppFeatures = {
 };
 export type WriteContext = {
     config: FEV4OPAConfig;
+    basePath: string;
+    rootCommonTemplateDirPath: string;
     rootV4TemplateDirPath: string;
     testOutDirPath: string;
     editor: Editor;
+    log?: Logger;
     journeyParams: JourneyParams;
+    hasPreexistingTests?: boolean;
+    incompatibleTestSetup?: boolean;
     dotFileExtension: DotFileExtension;
+    modifiedFiles: string[];
 };
 export type FormField = {
     fieldGroupQualifier?: string;

package/dist/utils/fileWritingUtils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Shared helpers for utilities that read, splice, and write back generated test files in place.
+ */
+/**
+ * Maximum file size, in characters, that the in-place splicers will attempt to update.
+ * Files larger than this are returned unchanged to prevent ReDoS on crafted inputs.
+ * Valid generator output is well within this limit.
+ */
+export declare const MAX_FILE_CONTENT_LENGTH = 20000;
+/**
+ * Escape regex metacharacters in `value` so it can be safely embedded in a `RegExp` pattern.
+ *
+ * @param value - the string to escape
+ * @returns the escaped string
+ */
+export declare function escapeRegex(value: string): string;
+/**
+ * Walk forward from `openBraceIdx` and return the index of the matching closing `}`,
+ * accounting for nested braces.
+ *
+ * @param content - the file content
+ * @param openBraceIdx - the index of the `{` that opens the block
+ * @returns the index of the matching closing `}` (or `content.length` if unterminated)
+ */
+export declare function findMatchingClosingBrace(content: string, openBraceIdx: number): number;
+/**
+ * Return the index immediately after the last `import ... from "..."` line in `content`,
+ * or `-1` if the content has no `import` lines.
+ *
+ * @param content - the file content to scan
+ * @returns the index immediately after the last import line, or -1 if none found
+ */
+export declare function findLastImportEnd(content: string): number;
+/**
+ * Insert `newImportLines` after the last existing `import` line in `content`.
+ * Returns `content` unchanged if it has no `import` lines.
+ *
+ * @param content - the file content
+ * @param newImportLines - the import lines to insert (no leading newline)
+ * @returns the updated content
+ */
+export declare function insertAfterLastImport(content: string, newImportLines: string[]): string;
+/**
+ * Locate a braced block introduced by a header pattern (e.g. `pages: {`) and return the
+ * indices of its opening and matching closing braces, accounting for nested braces.
+ *
+ * @param content - the file content
+ * @param headerRegex - regex matching the block header up to and including (or just before) the `{`
+ * @returns the brace indices, or undefined if the block can't be located
+ */
+export declare function findBracedBlock(content: string, headerRegex: RegExp): {
+    openBraceIdx: number;
+    closeBraceIdx: number;
+} | undefined;
+//# sourceMappingURL=fileWritingUtils.d.ts.map

package/dist/utils/fileWritingUtils.js

@@ -0,0 +1,103 @@
+/**
+ * Shared helpers for utilities that read, splice, and write back generated test files in place.
+ */
+/**
+ * Maximum file size, in characters, that the in-place splicers will attempt to update.
+ * Files larger than this are returned unchanged to prevent ReDoS on crafted inputs.
+ * Valid generator output is well within this limit.
+ */
+export const MAX_FILE_CONTENT_LENGTH = 20000;
+/**
+ * Escape regex metacharacters in `value` so it can be safely embedded in a `RegExp` pattern.
+ *
+ * @param value - the string to escape
+ * @returns the escaped string
+ */
+export function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`);
+}
+/**
+ * Walk forward from `openBraceIdx` and return the index of the matching closing `}`,
+ * accounting for nested braces.
+ *
+ * @param content - the file content
+ * @param openBraceIdx - the index of the `{` that opens the block
+ * @returns the index of the matching closing `}` (or `content.length` if unterminated)
+ */
+export function findMatchingClosingBrace(content, openBraceIdx) {
+    let depth = 1;
+    let index = openBraceIdx + 1;
+    while (index < content.length && depth > 0) {
+        const character = content[index];
+        if (character === '{') {
+            depth++;
+        }
+        else if (character === '}') {
+            depth--;
+        }
+        if (depth === 0) {
+            break;
+        }
+        index++;
+    }
+    return index;
+}
+/**
+ * Return the index immediately after the last `import ... from "..."` line in `content`,
+ * or `-1` if the content has no `import` lines.
+ *
+ * @param content - the file content to scan
+ * @returns the index immediately after the last import line, or -1 if none found
+ */
+export function findLastImportEnd(content) {
+    const importLineRegex = /^import\b[^\n]*?\bfrom[ \t]+["'][^"']+["'];?[ \t]*$/gm;
+    let lastImportEnd = -1;
+    let importMatch;
+    while ((importMatch = importLineRegex.exec(content)) !== null) {
+        lastImportEnd = importMatch.index + importMatch[0].length;
+    }
+    return lastImportEnd;
+}
+/**
+ * Insert `newImportLines` after the last existing `import` line in `content`.
+ * Returns `content` unchanged if it has no `import` lines.
+ *
+ * @param content - the file content
+ * @param newImportLines - the import lines to insert (no leading newline)
+ * @returns the updated content
+ */
+export function insertAfterLastImport(content, newImportLines) {
+    if (newImportLines.length === 0) {
+        return content;
+    }
+    const lastImportEnd = findLastImportEnd(content);
+    if (lastImportEnd < 0) {
+        return content;
+    }
+    const newImports = newImportLines.map((line) => `\n${line}`).join('');
+    return `${content.slice(0, lastImportEnd)}${newImports}${content.slice(lastImportEnd)}`;
+}
+/**
+ * Locate a braced block introduced by a header pattern (e.g. `pages: {`) and return the
+ * indices of its opening and matching closing braces, accounting for nested braces.
+ *
+ * @param content - the file content
+ * @param headerRegex - regex matching the block header up to and including (or just before) the `{`
+ * @returns the brace indices, or undefined if the block can't be located
+ */
+export function findBracedBlock(content, headerRegex) {
+    const match = headerRegex.exec(content);
+    if (!match) {
+        return undefined;
+    }
+    const openBraceIdx = content.indexOf('{', match.index + match[0].length - 1);
+    if (openBraceIdx < 0) {
+        return undefined;
+    }
+    const closeBraceIdx = findMatchingClosingBrace(content, openBraceIdx);
+    if (closeBraceIdx >= content.length) {
+        return undefined;
+    }
+    return { openBraceIdx, closeBraceIdx };
+}
+//# sourceMappingURL=fileWritingUtils.js.map

package/dist/utils/journeyRunnerUtils.d.ts

@@ -0,0 +1,64 @@
+import type { Editor } from 'mem-fs-editor';
+import type { Logger } from '@sap-ux/logger';
+import { DotFileExtension } from '../types.js';
+/**
+ * Page entry to splice into an existing JourneyRunner.js / JourneyRunner.ts.
+ *
+ * The variable name and `onThe...` key emitted by the splicer always use the `Generated` suffix
+ * (e.g. `TravelListGenerated`, `onTheTravelListGenerated`) so that generator-owned `.gen` page
+ * entries can coexist with hand-authored pages bound to the same `targetKey`.
+ */
+export interface OpaPageWriteInfo {
+    /** The page's targetKey; used as the base for the `onThe<targetKey>Generated` key. */
+    targetKey: string;
+    /** The app module path prefix (e.g. "project1/test/integration/pages") */
+    appPath: string;
+    /** The file name of the page object, including the `.gen` suffix (e.g. "TravelList.gen") */
+    fileName: string;
+    /** The file extension of the page object, including the leading dot (e.g. ".js" or ".ts") */
+    dotFileExtension: string;
+    /** The framework page template (`'ListReport'` or `'ObjectPage'`); only needed by the TS splicer. */
+    template?: string;
+    /** The app id (sap.app.id from the manifest); only needed by the TS splicer. */
+    appID?: string;
+    /** The component id (defined in the target section); only needed by the TS splicer. */
+    componentID?: string;
+    /** The entity set name (if the page uses an entitySet rather than a contextPath); only needed by the TS splicer. */
+    entitySet?: string;
+    /** The context path (if the page uses a contextPath rather than an entitySet); only needed by the TS splicer. */
+    contextPath?: string;
+}
+/**
+ * Splice new page entries into the three locations of an existing AMD `JourneyRunner.js`:
+ * the `sap.ui.define` dependency array, the function parameter list, and the `pages` object literal.
+ * Pages already referenced by their `.gen` module path are skipped; all other content is preserved.
+ *
+ * @param fileContent - the full content of the JourneyRunner.js file
+ * @param pages - pages to add
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+export declare function splicePageIntoJourneyRunner(fileContent: string, pages: OpaPageWriteInfo[]): string;
+/**
+ * Read the JourneyRunner from disk, splice new page entries into it, and write the result back.
+ * Pages already present are skipped. Dispatches between the AMD (`.js`) and ES module (`.ts`) splicers.
+ *
+ * @param pages - pages to add
+ * @param testOutDirPath - path to the test output directory (`.../webapp/test`)
+ * @param fs - mem-fs-editor instance used to read and write the file
+ * @param dotFileExtension - file extension of the JourneyRunner ('.ts' or '.js'); defaults to '.js'
+ * @param log - optional logger instance used to surface warnings when the file
+ *   cannot be read or updated
+ * @returns true if the file was written, false otherwise
+ */
+export declare function addPagesToJourneyRunner(pages: OpaPageWriteInfo[], testOutDirPath: string, fs: Editor, dotFileExtension?: DotFileExtension, log?: Logger): boolean;
+/**
+ * Splice new page entries into an existing TypeScript `JourneyRunner.ts` by adding the
+ * required `Custom<targetKey>Generated` imports and an entry inside `pages: { ... }`.
+ * Pages already imported are skipped; all other content is preserved.
+ *
+ * @param fileContent - the full content of the JourneyRunner.ts file
+ * @param pages - pages to add
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+export declare function splicePageIntoJourneyRunnerTs(fileContent: string, pages: OpaPageWriteInfo[]): string;
+//# sourceMappingURL=journeyRunnerUtils.d.ts.map

package/dist/utils/journeyRunnerUtils.js

@@ -0,0 +1,251 @@
+import { join } from 'node:path';
+import { t } from '../i18n.js';
+import { DotFileExtension } from '../types.js';
+import { MAX_FILE_CONTENT_LENGTH, escapeRegex, findBracedBlock, insertAfterLastImport } from './fileWritingUtils.js';
+/**
+ * Returns the relative path from the test output directory to the JourneyRunner file
+ * for the requested file extension.
+ *
+ * @param dotFileExtension - file extension ('.ts' or '.js')
+ * @returns the relative path
+ */
+function getJourneyRunnerFilePath(dotFileExtension) {
+    return join('integration', 'pages', `JourneyRunner${dotFileExtension}`);
+}
+/**
+ * Splice new page entries into the three locations of an existing AMD `JourneyRunner.js`:
+ * the `sap.ui.define` dependency array, the function parameter list, and the `pages` object literal.
+ * Pages already referenced by their `.gen` module path are skipped; all other content is preserved.
+ *
+ * @param fileContent - the full content of the JourneyRunner.js file
+ * @param pages - pages to add
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+export function splicePageIntoJourneyRunner(fileContent, pages) {
+    if (fileContent.length > MAX_FILE_CONTENT_LENGTH) {
+        return fileContent;
+    }
+    // Determine which pages are not yet present by checking the define array
+    const toAdd = pages.filter((page) => {
+        const modulePath = `${page.appPath}/test/integration/pages/${page.fileName}`;
+        return !fileContent.includes(`"${modulePath}"`);
+    });
+    if (toAdd.length === 0) {
+        return fileContent;
+    }
+    let result = fileContent;
+    result = spliceIntoDefineArray(result, toAdd);
+    result = spliceIntoFunctionParams(result, toAdd);
+    result = spliceIntoJsPagesObject(result, toAdd);
+    return result;
+}
+/**
+ * Insert new entries before the closing `]` of the `sap.ui.define([...])` dependency array.
+ *
+ * @param content - the file content
+ * @param toAdd - pages to add
+ * @returns the updated content (or unchanged if the define array can't be located)
+ */
+function spliceIntoDefineArray(content, toAdd) {
+    const defineArrayRegex = /sap\.ui\.define\s*\(\s*\[([^\]]*)\]\s*,\s*function/d;
+    const match = defineArrayRegex.exec(content);
+    if (!match?.indices?.[1]) {
+        return content;
+    }
+    const [bodyStart, bodyEnd] = match.indices[1];
+    const arrayBody = content.slice(bodyStart, bodyEnd);
+    const indentMatch = /^([ \t]+)"/m.exec(arrayBody);
+    const indent = indentMatch ? indentMatch[1] : '\t';
+    const newEntries = toAdd
+        .map((page) => `${indent}"${page.appPath}/test/integration/pages/${page.fileName}",`)
+        .join('\n');
+    return insertBeforePosition(content, bodyEnd, newEntries);
+}
+/**
+ * Append the new `, <Target>Generated` parameters to the JourneyRunner module factory's signature.
+ *
+ * @param content - the file content
+ * @param toAdd - pages to add
+ * @returns the updated content (or unchanged if the function signature can't be located)
+ */
+function spliceIntoFunctionParams(content, toAdd) {
+    const funcParamRegex = /\]\s*,\s*function\s*\(([^)]*)\)\s*\{/d;
+    const match = funcParamRegex.exec(content);
+    if (!match?.indices?.[1]) {
+        return content;
+    }
+    const [, paramEnd] = match.indices[1];
+    const newParams = toAdd.map((page) => `, ${page.targetKey}Generated`).join('');
+    return `${content.slice(0, paramEnd)}${newParams}${content.slice(paramEnd)}`;
+}
+/**
+ * Insert new `onThe<Target>Generated: <Target>Generated,` entries into the AMD `pages: { ... }`
+ * object literal, using brace counting to handle nested braces in user hand-edits.
+ *
+ * @param content - the file content
+ * @param toAdd - pages to add
+ * @returns the updated content (or unchanged if the pages object can't be located)
+ */
+function spliceIntoJsPagesObject(content, toAdd) {
+    const block = findBracedBlock(content, /pages\s*:\s*\{/);
+    if (!block) {
+        return content;
+    }
+    const { openBraceIdx, closeBraceIdx } = block;
+    const pagesBody = content.slice(openBraceIdx + 1, closeBraceIdx);
+    const pageIndentMatch = /^([ \t]+)on/m.exec(pagesBody);
+    const pageIndent = pageIndentMatch ? pageIndentMatch[1] : '\t\t\t';
+    const newPageEntries = toAdd
+        .map((page) => `${pageIndent}onThe${page.targetKey}Generated: ${page.targetKey}Generated,`)
+        .join('\n');
+    return insertBeforePosition(content, closeBraceIdx, newPageEntries);
+}
+/**
+ * Insert `newEntries` immediately before `position` in `content`, preserving the trailing
+ * whitespace at `position` and ensuring the preceding token ends with a comma.
+ *
+ * @param content - the file content
+ * @param position - the index to insert before
+ * @param newEntries - the new lines (no leading newline) to insert
+ * @returns the updated content
+ */
+function insertBeforePosition(content, position, newEntries) {
+    const trimmedEnd = content.slice(0, position).trimEnd();
+    const commaFix = trimmedEnd.endsWith(',') ? '' : ',';
+    const trailingWhitespace = content.slice(trimmedEnd.length, position);
+    return `${trimmedEnd}${commaFix}\n${newEntries}${trailingWhitespace}${content.slice(position)}`;
+}
+/**
+ * Read the JourneyRunner from disk, splice new page entries into it, and write the result back.
+ * Pages already present are skipped. Dispatches between the AMD (`.js`) and ES module (`.ts`) splicers.
+ *
+ * @param pages - pages to add
+ * @param testOutDirPath - path to the test output directory (`.../webapp/test`)
+ * @param fs - mem-fs-editor instance used to read and write the file
+ * @param dotFileExtension - file extension of the JourneyRunner ('.ts' or '.js'); defaults to '.js'
+ * @param log - optional logger instance used to surface warnings when the file
+ *   cannot be read or updated
+ * @returns true if the file was written, false otherwise
+ */
+export function addPagesToJourneyRunner(pages, testOutDirPath, fs, dotFileExtension = DotFileExtension.JS, log) {
+    if (pages.length === 0) {
+        return false;
+    }
+    try {
+        const filePath = join(testOutDirPath, getJourneyRunnerFilePath(dotFileExtension));
+        const content = fs.read(filePath);
+        if (content.length > MAX_FILE_CONTENT_LENGTH) {
+            log?.warn(t('warn.cannotUpdateJourneyRunner'));
+            return false;
+        }
+        const splice = dotFileExtension === DotFileExtension.TS ? splicePageIntoJourneyRunnerTs : splicePageIntoJourneyRunner;
+        const updated = splice(content, pages);
+        if (updated !== content) {
+            fs.write(filePath, updated);
+            return true;
+        }
+    }
+    catch {
+        log?.warn(t('warn.cannotUpdateJourneyRunner'));
+    }
+    return false;
+}
+/**
+ * Filter `pages` down to those whose `Custom<targetKey>Generated` import line is not yet present.
+ * The import path matched is `./<fileName>` (with the `.gen` suffix), so user-authored bindings
+ * to `./<targetKey>` are correctly treated as different.
+ *
+ * @param fileContent - the existing JourneyRunner.ts content
+ * @param pages - candidate pages to splice in
+ * @returns the subset of pages that need to be added
+ */
+function findPagesToAdd(fileContent, pages) {
+    return pages.filter((page) => {
+        const importPattern = new RegExp(String.raw `from\s+"\./${escapeRegex(page.fileName)}"`);
+        return !importPattern.test(fileContent);
+    });
+}
+/**
+ * Build the source-code block for a single new entry in the `pages: { ... }` object literal.
+ *
+ * @param page - the page to render
+ * @param pageIndent - leading whitespace for the entry's outer line
+ * @param innerIndent - leading whitespace for the entry's nested lines
+ * @returns the multi-line source block
+ */
+function buildPageEntry(page, pageIndent, innerIndent) {
+    const framework = page.template ?? 'ListReport';
+    const innerProps = [
+        `${innerIndent}    appId: "${page.appID ?? ''}"`,
+        `${innerIndent}    componentId: "${page.componentID ?? ''}"`
+    ];
+    if (page.entitySet) {
+        innerProps.push(`${innerIndent}    entitySet: "${page.entitySet}"`);
+    }
+    if (page.contextPath) {
+        innerProps.push(`${innerIndent}    contextPath: "${page.contextPath}"`);
+    }
+    return [
+        `${pageIndent}onThe${page.targetKey}Generated: new ${framework}(`,
+        `${innerIndent}{`,
+        innerProps.join(',\n'),
+        `${innerIndent}},`,
+        `${innerIndent}Custom${page.targetKey}Generated`,
+        `${pageIndent})`
+    ].join('\n');
+}
+/**
+ * Insert new page entries inside the `pages: { ... }` object literal of `content`.
+ * Returns `content` unchanged if it has no `pages: {` block.
+ *
+ * @param content - the file content
+ * @param toAdd - the pages to add
+ * @returns the updated content
+ */
+function insertIntoPagesObject(content, toAdd) {
+    const block = findBracedBlock(content, /pages\s*:\s*\{/);
+    if (!block) {
+        return content;
+    }
+    const { openBraceIdx, closeBraceIdx } = block;
+    const pagesBody = content.slice(openBraceIdx + 1, closeBraceIdx);
+    // Detect indentation from the first existing page entry
+    const pageIndentMatch = /^([ \t]+)on/m.exec(pagesBody);
+    const pageIndent = pageIndentMatch ? pageIndentMatch[1] : '        ';
+    const innerIndent = pageIndent + '    ';
+    const newPageEntries = toAdd.map((page) => buildPageEntry(page, pageIndent, innerIndent)).join(',\n');
+    // Ensure the last existing entry ends with a comma before we insert after it.
+    const trimmedPagesEnd = content.slice(0, closeBraceIdx).trimEnd();
+    const needsComma = !trimmedPagesEnd.endsWith(',') && !trimmedPagesEnd.endsWith('{');
+    const commaFix = needsComma ? ',' : '';
+    const trailingWhitespace = content.slice(trimmedPagesEnd.length, closeBraceIdx);
+    return `${trimmedPagesEnd}${commaFix}\n${newPageEntries}${trailingWhitespace}${content.slice(closeBraceIdx)}`;
+}
+/**
+ * Splice new page entries into an existing TypeScript `JourneyRunner.ts` by adding the
+ * required `Custom<targetKey>Generated` imports and an entry inside `pages: { ... }`.
+ * Pages already imported are skipped; all other content is preserved.
+ *
+ * @param fileContent - the full content of the JourneyRunner.ts file
+ * @param pages - pages to add
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+export function splicePageIntoJourneyRunnerTs(fileContent, pages) {
+    if (fileContent.length > MAX_FILE_CONTENT_LENGTH) {
+        return fileContent;
+    }
+    const toAdd = findPagesToAdd(fileContent, pages);
+    if (toAdd.length === 0) {
+        return fileContent;
+    }
+    // Determine which framework imports (ListReport / ObjectPage) are missing and need to be added.
+    const frameworkTemplates = Array.from(new Set(toAdd.map((page) => page.template).filter((template) => Boolean(template))));
+    const missingFrameworkImports = frameworkTemplates.filter((template) => !fileContent.includes(`from "sap/fe/test/${template}"`));
+    const newImportLines = [
+        ...missingFrameworkImports.map((template) => `import ${template} from "sap/fe/test/${template}";`),
+        ...toAdd.map((page) => `import Custom${page.targetKey}Generated from "./${page.fileName}";`)
+    ];
+    const withImports = insertAfterLastImport(fileContent, newImportLines);
+    return insertIntoPagesObject(withImports, toAdd);
+}
+//# sourceMappingURL=journeyRunnerUtils.js.map

package/dist/utils/opaJourneyTypesUtils.d.ts

@@ -0,0 +1,27 @@
+import type { Editor } from 'mem-fs-editor';
+import type { Logger } from '@sap-ux/logger';
+import type { OpaPageWriteInfo } from './journeyRunnerUtils.js';
+/**
+ * Splice new journey entries into an existing `OpaJourneyTypes.d.ts`: framework imports,
+ * per-page custom actions/assertions imports, and `onThe<targetKey>Generated` members in
+ * the `When` and `Then` unions. Pages already imported are skipped; all other content is preserved.
+ *
+ * @param fileContent - the full content of the OpaJourneyTypes.d.ts file
+ * @param pages - pages to add
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+export declare function spliceJourneysIntoOpaJourneyTypes(fileContent: string, pages: OpaPageWriteInfo[]): string;
+/**
+ * Read `OpaJourneyTypes.d.ts` from the project, splice entries for new pages, and write
+ * the result back. Pages already present are skipped. If the file does not exist or
+ * cannot be read, logs a warning and returns without writing.
+ *
+ * @param pages - pages whose journeys should be reflected in OpaJourneyTypes.d.ts
+ * @param testOutDirPath - path to the test output directory (`.../webapp/test`)
+ * @param fs - mem-fs-editor instance used to read and write the file
+ * @param log - optional logger instance used to surface warnings when the file
+ *   cannot be read or updated
+ * @returns true if the file was written, false otherwise
+ */
+export declare function addJourneysToOpaJourneyTypes(pages: OpaPageWriteInfo[], testOutDirPath: string, fs: Editor, log?: Logger): boolean;
+//# sourceMappingURL=opaJourneyTypesUtils.d.ts.map