sb-mig 5.8.0 → 6.0.0-beta.10

package/README.md

@@ -13,7 +13,7 @@ If you've found an issue or you have feature request - <a href="https://github.c
 
 |      |              |
 | ---- | ------------ |
-| Node | LTS (18.x.x) |
+| Node | 22.x.x or >=24.x.x |
 
 # 5.x.x version released!
 
@@ -32,7 +32,7 @@ If you've found an issue or you have feature request - <a href="https://github.c
 
 ## Breaking changes
 
-- Please note that sb-mig no longer extends support for Node versions older than 18.x.x, as part of its adoption of native ESM support.
+- Please note that sb-mig no longer extends support for Node versions older than 22.x.x, as part of its adoption of native ESM support.
 - The sb-mig backup command has now been aligned with all other commands, causing minor changes in its execution (although functionalities have been preserved).
 
 Do not hesitate to get in touch if you encounter any issues or require further clarification on any points.
@@ -113,6 +113,40 @@ module.exports = {
 };
 ```
 
+## Programmatic asset API
+
+The public management API exposes asset helpers for uploading a local file and updating existing asset metadata:
+
+```ts
+import { managementApi } from "sb-mig/dist/api/managementApi.js";
+
+await managementApi.assets.createAsset(
+  {
+    spaceId: "12345",
+    pathToFile: "./public/image.jpg",
+    payload: {
+      asset_folder_id: 67890,
+      validate_upload: 1,
+    },
+  },
+  config,
+);
+
+await managementApi.assets.updateAsset(
+  {
+    spaceId: "12345",
+    assetId: 98765,
+    payload: {
+      meta_data: {
+        alt: "Image alt text",
+        title: "Image title",
+      },
+    },
+  },
+  config,
+);
+```
+
 # Schema documentation:
 
 ## Basics

package/dist/api/assets/assets.d.ts

@@ -1,6 +1,8 @@
-import type { GetAllAssets, GetAssetById, GetAssetByName, MigrateAsset } from "./assets.types.js";
+import type { CreateAsset, GetAllAssets, GetAssetById, GetAssetByName, MigrateAsset, UpdateAsset } from "./assets.types.js";
 export declare const getAllAssets: GetAllAssets;
 export declare const getAssetByName: GetAssetByName;
 export declare const migrateAsset: MigrateAsset;
+export declare const createAsset: CreateAsset;
+export declare const updateAsset: UpdateAsset;
 export declare const getAssetById: GetAssetById;
 export declare const getAsset: (assetName: string | undefined) => Promise<void>;

package/dist/api/assets/assets.js

@@ -5,6 +5,24 @@ import FormData from "form-data";
 import { createDir, isDirectoryExists } from "../../utils/files.js";
 import Logger from "../../utils/logger.js";
 import { getFileName, getSizeFromURL } from "../../utils/string-utils.js";
+const isStoryblokSize = (size) => Boolean(size && /^\d+x\d+$/i.test(size));
+const prepareSignedUploadPayload = (payload) => {
+    const { filename, asset_folder_id, id, size, validate_upload } = payload;
+    const inferredSize = isStoryblokSize(size)
+        ? size
+        : isStoryblokSize(getSizeFromURL(filename))
+            ? getSizeFromURL(filename)
+            : undefined;
+    return {
+        filename: getFileName(filename),
+        ...(asset_folder_id === undefined || asset_folder_id === null
+            ? {}
+            : { asset_folder_id }),
+        ...(id === undefined ? {} : { id }),
+        ...(inferredSize ? { size: inferredSize } : {}),
+        ...(validate_upload === undefined ? {} : { validate_upload }),
+    };
+};
 // GET
 export const getAllAssets = async (args, config) => {
     const { spaceId, search } = args;
@@ -38,18 +56,12 @@ export const getAssetByName = async ({ spaceId, fileName }, config) => {
 };
 const requestSignedUploadUrl = ({ spaceId, payload }, config) => {
     const { sbApi, debug } = config;
-    const { filename: _1, asset_folder_id, ext_id, space_id, deleted_at: _2, ...restPayload } = payload;
-    const filename = getFileName(payload.filename);
-    const size = getSizeFromURL(payload.filename);
+    const signedUploadPayload = prepareSignedUploadPayload(payload);
     return sbApi
-        .post(`spaces/${spaceId}/assets/`, {
-        filename,
-        size,
-        ...restPayload,
-    })
+        .post(`spaces/${spaceId}/assets/`, signedUploadPayload)
         .then((signedResponseObject) => {
         if (debug) {
-            Logger.log(`Signed upload URL has been requested for ${filename}.`);
+            Logger.log(`Signed upload URL has been requested for ${signedUploadPayload.filename}.`);
         }
         return signedResponseObject.data; // this is very bad... but storyblok-js-client types are pretty broken
     })
@@ -67,15 +79,20 @@ const uploadFile = ({ signedResponseObject, pathToFile }) => {
     // also append the file read stream
     form.append("file", fs.createReadStream(file));
     // submit your form
-    form.submit(signedResponseObject.post_url, async (err, res) => {
-        const statusCode = res.statusCode;
-        if (statusCode === 204) {
-            Logger.upload(`Asset uploaded ${getFileName(file)}`);
-        }
-        else {
-            if (err)
-                throw err;
-        }
+    return new Promise((resolve, reject) => {
+        form.submit(signedResponseObject.post_url, (err, res) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            const statusCode = res?.statusCode;
+            if (statusCode === 204) {
+                Logger.upload(`Asset uploaded ${getFileName(file)}`);
+                resolve();
+                return;
+            }
+            reject(new Error(`Asset upload failed with status code ${statusCode ?? "unknown"}`));
+        });
     });
 };
 const downloadAsset = async (args, config) => {
@@ -121,6 +138,31 @@ export const migrateAsset = async ({ migrateTo, payload, syncDirection }, config
     }
     return true;
 };
+export const createAsset = async ({ spaceId, pathToFile, payload = {} }, config) => {
+    const signedResponseObject = await requestSignedUploadUrl({
+        spaceId,
+        payload: {
+            ...payload,
+            filename: payload.filename ?? pathToFile,
+        },
+    }, config);
+    await uploadFile({ signedResponseObject, pathToFile });
+    return signedResponseObject;
+};
+export const updateAsset = async ({ spaceId, assetId, payload }, config) => {
+    const { sbApi } = config;
+    Logger.log(`Trying to update asset with id ${assetId}.`);
+    return sbApi
+        .put(`spaces/${spaceId}/assets/${assetId}`, payload)
+        .then((res) => {
+        Logger.success(`Asset '${assetId}' has been updated.`);
+        return res.data;
+    })
+        .catch((err) => {
+        Logger.error(`${err.message} in updateAsset function for asset ${assetId}`);
+        throw err;
+    });
+};
 // GET
 export const getAssetById = async ({ spaceId, assetId }, config) => {
     const { sbApi } = config;

package/dist/api/assets/assets.types.d.ts

@@ -35,6 +35,29 @@ export interface SBAllAssetRequestResult {
 }
 export type SignedResponseObject = any;
 export type AssetPayload = Omit<SBAsset, "updated_at" | "created_at" | "id">;
+export interface SignedUploadPayload {
+    filename: string;
+    id?: number;
+    asset_folder_id?: number | null;
+    size?: string;
+    validate_upload?: number;
+}
+export type CreateAssetPayload = Omit<SignedUploadPayload, "filename" | "id"> & Partial<Pick<SignedUploadPayload, "filename">>;
+export type UpdateAssetPayload = {
+    asset_folder_id?: number | null;
+    internal_tag_ids?: number[];
+    is_private?: boolean;
+    locked?: boolean;
+    meta_data?: {
+        alt?: string;
+        copyright?: string;
+        source?: string;
+        title?: string;
+        [key: string]: unknown;
+    };
+    publish_at?: string | null;
+    [key: string]: unknown;
+};
 export type GetAllAssets = ({ spaceId, }: {
     spaceId: string;
     search?: string;
@@ -52,16 +75,26 @@ export type MigrateAsset = ({ migrateTo, payload, syncDirection, }: {
     payload: AssetPayload;
     syncDirection: SyncDirection;
 }, config: RequestBaseConfig) => Promise<boolean>;
+export type CreateAsset = ({ spaceId, pathToFile, payload, }: {
+    spaceId: string;
+    pathToFile: string;
+    payload?: CreateAssetPayload;
+}, config: RequestBaseConfig) => Promise<SignedResponseObject>;
+export type UpdateAsset = ({ spaceId, assetId, payload, }: {
+    spaceId: string;
+    assetId: number;
+    payload: UpdateAssetPayload;
+}, config: RequestBaseConfig) => Promise<any>;
 export type UploadFile = ({ signedResponseObject, pathToFile, }: {
     signedResponseObject: SignedResponseObject;
     pathToFile: string;
-}) => void;
+}) => Promise<void>;
 export type FinalizeUpload = ({ signedResponseObject, }: {
     signedResponseObject: SignedResponseObject;
 }) => void;
 export type RequestSignedUploadUrl = ({ spaceId, payload, }: {
     spaceId: string;
-    payload: AssetPayload;
+    payload: AssetPayload | SignedUploadPayload;
 }, config: RequestBaseConfig) => Promise<any>;
 export type DownloadAsset = (args: {
     payload: AssetPayload;

package/dist/api/assets/index.d.ts

@@ -1 +1,2 @@
-export { getAllAssets, migrateAsset, getAsset, getAssetById, getAssetByName, } from "./assets.js";
+export { getAllAssets, createAsset, migrateAsset, getAsset, getAssetById, getAssetByName, updateAsset, } from "./assets.js";
+export type { CreateAssetPayload, SignedUploadPayload, UpdateAssetPayload, } from "./assets.types.js";

package/dist/api/assets/index.js

@@ -1 +1 @@
-export { getAllAssets, migrateAsset, getAsset, getAssetById, getAssetByName, } from "./assets.js";
+export { getAllAssets, createAsset, migrateAsset, getAsset, getAssetById, getAssetByName, updateAsset, } from "./assets.js";

package/dist/api/components/components.js

@@ -109,7 +109,10 @@ export const removeComponent = (component, config) => {
     return sbApi
         .delete(`spaces/${spaceId}/components/${id}`, {})
         .then((res) => res.data)
-        .catch((err) => console.error(err));
+        .catch((err) => {
+        console.error(err);
+        throw err;
+    });
 };
 /*
  *
@@ -165,7 +168,10 @@ export const removeComponentGroup = (componentGroup, config) => {
     return sbApi
         .delete(`spaces/${spaceId}/component_groups/${id}`, {})
         .then((res) => res.data)
-        .catch((err) => console.error(err));
+        .catch((err) => {
+        console.error(err);
+        throw err;
+    });
 };
 export const createComponentsGroup = (groupName, config) => {
     const { spaceId, sbApi } = config;

package/dist/api/components/components.sync.js

@@ -27,6 +27,9 @@ const defaultProgress = (event) => {
     }
 };
 import { createComponent, createComponentsGroup, getAllComponents, getAllComponentsGroups, removeComponent, removeComponentGroup, updateComponent, } from "./components.js";
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 async function ensureComponentGroupsExist(groupNames, config, options = {}) {
     try {
         const existing = await getAllComponentsGroups(config);
@@ -79,10 +82,34 @@ export async function syncComponentsData(args, config) {
             }
         }
         else {
-            await Promise.allSettled([
-                ...(existingComponents ?? []).map((c) => removeComponent(c, config)),
-                ...(existingGroups ?? []).map((g) => removeComponentGroup(g, config)),
-            ]);
+            const removalTargets = [
+                ...(existingComponents ?? []).map((component) => ({
+                    type: "component",
+                    name: String(component?.name ?? component?.id ?? "unknown"),
+                    remove: () => removeComponent(component, config),
+                })),
+                ...(existingGroups ?? []).map((group) => ({
+                    type: "component group",
+                    name: String(group?.name ?? group?.id ?? "unknown"),
+                    remove: () => removeComponentGroup(group, config),
+                })),
+            ];
+            const removalResults = await Promise.allSettled(removalTargets.map((target) => target.remove()));
+            removalResults.forEach((removalResult, index) => {
+                if (removalResult.status === "fulfilled")
+                    return;
+                const target = removalTargets[index];
+                if (!target)
+                    return;
+                const name = `${target.type} '${target.name}'`;
+                const message = getErrorMessage(removalResult.reason);
+                result.skipped.push(name);
+                result.errors.push({
+                    name,
+                    message: `SSOT removal failed: ${message}`,
+                });
+                Logger.warning(`Could not remove ${name} during SSOT sync: ${message}`);
+            });
         }
     }
     const nonEmptyComponents = components.filter((c) => !isObjectEmpty(c));
@@ -164,7 +191,7 @@ export async function syncComponentsData(args, config) {
         catch (error) {
             result.errors.push({
                 name,
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
             progress({
                 type: "progress",
@@ -172,7 +199,7 @@ export async function syncComponentsData(args, config) {
                 total: totalComponents,
                 name,
                 action: "error",
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
         }
     }
@@ -213,7 +240,7 @@ export async function syncComponentsData(args, config) {
         catch (error) {
             result.errors.push({
                 name,
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
             progress({
                 type: "progress",
@@ -221,7 +248,7 @@ export async function syncComponentsData(args, config) {
                 total: totalComponents,
                 name,
                 action: "error",
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
         }
     }

package/dist/api/data-migration/component-data-migration.d.ts

@@ -1,3 +1,4 @@
+import type { PublishLanguagesOption } from "../stories/stories.types.js";
 import type { RequestBaseConfig } from "../utils/request.js";
 import { type MigrationComponentAliasesByMigration, type MigrationComponentOverridesByMigration } from "./migration-component-scope.js";
 import { type PreparedMigrationValidator } from "./migration-validation.js";
@@ -43,6 +44,8 @@ interface MigrateItems {
         startsWith?: string;
     };
     dryRun?: boolean;
+    publish?: boolean;
+    publishLanguages?: PublishLanguagesOption;
     fromFilePath?: string;
     fileName?: string;
     preparedMigrationConfigs?: PreparedMigrationConfig[];
@@ -67,8 +70,8 @@ export declare const runMigrationPipelineInMemory: ({ itemType, itemsToMigrate,
     itemsToMigrate: any[];
     preparedMigrationConfigs: PreparedMigrationConfig[];
 }) => MigrationPipelineResult;
-export declare const migrateAllComponentsDataInStories: ({ itemType, migrationConfig, migrateFrom, from, to, filters, dryRun, fromFilePath, fileName, migrationComponentAliases, migrationComponentOverrides, }: Omit<MigrateItems, "componentsToMigrate" | "preparedMigrationConfigs">, config: RequestBaseConfig) => Promise<void>;
-export declare const doTheMigration: ({ itemType, from, itemsToMigrate, migrationConfig, migrationConfigs, to, dryRun, migrateFrom, fromFilePath, fileName, }: {
+export declare const migrateAllComponentsDataInStories: ({ itemType, migrationConfig, migrateFrom, from, to, filters, dryRun, publish, publishLanguages, fromFilePath, fileName, migrationComponentAliases, migrationComponentOverrides, }: Omit<MigrateItems, "componentsToMigrate" | "preparedMigrationConfigs">, config: RequestBaseConfig) => Promise<void>;
+export declare const doTheMigration: ({ itemType, from, itemsToMigrate, migrationConfig, migrationConfigs, to, dryRun, publish, publishLanguages, migrateFrom, fromFilePath, fileName, }: {
     itemType?: "story" | "preset";
     from: string;
     itemsToMigrate: any[];
@@ -76,9 +79,11 @@ export declare const doTheMigration: ({ itemType, from, itemsToMigrate, migratio
     migrationConfigs?: PreparedMigrationConfig[];
     to: string;
     dryRun?: boolean;
+    publish?: boolean;
+    publishLanguages?: PublishLanguagesOption;
     migrateFrom: MigrateFrom;
     fromFilePath?: string;
     fileName?: string;
 }, config: RequestBaseConfig) => Promise<void>;
-export declare const migrateProvidedComponentsDataInStories: ({ itemType, migrationConfig, migrateFrom, from, to, componentsToMigrate, filters, dryRun, fromFilePath, fileName, preparedMigrationConfigs, migrationComponentAliases, migrationComponentOverrides, }: MigrateItems, config: RequestBaseConfig) => Promise<void>;
+export declare const migrateProvidedComponentsDataInStories: ({ itemType, migrationConfig, migrateFrom, from, to, componentsToMigrate, filters, dryRun, publish, publishLanguages, fromFilePath, fileName, preparedMigrationConfigs, migrationComponentAliases, migrationComponentOverrides, }: MigrateItems, config: RequestBaseConfig) => Promise<void>;
 export {};

package/dist/api/data-migration/component-data-migration.js

@@ -9,6 +9,7 @@ import { isObjectEmpty } from "../../utils/object-utils.js";
 import { managementApi } from "../managementApi.js";
 import { buildPreMigrationBackupBaseName, resolveOutputFileBaseName, shouldUseDatestampForArtifacts, } from "./file-naming.js";
 import { extendMigrationMapperWithAliases, resolveMigrationComponentsToMigrate, } from "./migration-component-scope.js";
+import { saveMigrationRunLog } from "./migration-run-log.js";
 import { discoverMigrationValidatorForMigrationFile, MigrationValidationFailedError, runPreparedMigrationValidator, } from "./migration-validation.js";
 import { summarizeMutationWriteResults } from "./write-summary.js";
 export const normalizeMigrationConfigNames = (migrationConfig) => {
@@ -245,7 +246,6 @@ const applySingleMigrationToItems = ({ itemType, itemsToMigrate, preparedMigrati
     };
 };
 export const runMigrationPipelineInMemory = ({ itemType, itemsToMigrate, preparedMigrationConfigs, }) => {
-    const originalItems = deepClone(itemsToMigrate);
     let workingItems = deepClone(itemsToMigrate);
     const stepReports = [];
     for (const preparedMigrationConfig of preparedMigrationConfigs) {
@@ -282,7 +282,7 @@ export const runMigrationPipelineInMemory = ({ itemType, itemsToMigrate, prepare
         stepReports.push(stepReport);
     }
     const changedItems = workingItems.filter((item, index) => {
-        const originalItem = originalItems[index];
+        const originalItem = itemsToMigrate[index];
         if (!originalItem) {
             return true;
         }
@@ -295,7 +295,7 @@ export const runMigrationPipelineInMemory = ({ itemType, itemsToMigrate, prepare
         totalItems: workingItems.length,
     };
 };
-const savePipelineSummary = async ({ artifactBaseName, useDatestamp, from, itemType, dryRun, migrateFrom, fromFilePath, pipelineResult, }, config) => {
+const savePipelineSummary = async ({ artifactBaseName, useDatestamp, from, itemType, dryRun, publish, publishLanguages, migrateFrom, fromFilePath, pipelineResult, }, config) => {
     await createAndSaveToFile({
         datestamp: useDatestamp,
         ext: "json",
@@ -308,6 +308,12 @@ const savePipelineSummary = async ({ artifactBaseName, useDatestamp, from, itemT
                 from,
                 fromFilePath: fromFilePath || null,
             },
+            writeMode: itemType === "story" && publish ? "publish" : "save",
+            publishLanguages: itemType === "story" && publish
+                ? {
+                    requested: publishLanguages,
+                }
+                : null,
             totalItems: pipelineResult.totalItems,
             totalChangedItems: pipelineResult.changedItems.length,
             steps: pipelineResult.stepReports,
@@ -378,7 +384,7 @@ const loadItemsToMigrate = async ({ itemType, migrateFrom, from, filters, fromFi
         spaceId: from,
     });
 };
-export const migrateAllComponentsDataInStories = async ({ itemType, migrationConfig, migrateFrom, from, to, filters, dryRun, fromFilePath, fileName, migrationComponentAliases, migrationComponentOverrides, }, config) => {
+export const migrateAllComponentsDataInStories = async ({ itemType, migrationConfig, migrateFrom, from, to, filters, dryRun, publish, publishLanguages, fromFilePath, fileName, migrationComponentAliases, migrationComponentOverrides, }, config) => {
     Logger.warning(`Trying to migrate all ${itemType} from ${migrateFrom}, ${from} to ${to}...`);
     const preparedMigrationConfigs = prepareMigrationConfigs({
         migrationConfig,
@@ -397,12 +403,14 @@ export const migrateAllComponentsDataInStories = async ({ itemType, migrationCon
         to,
         filters,
         dryRun,
+        publish,
+        publishLanguages,
         fromFilePath,
         fileName,
         preparedMigrationConfigs,
     }, config);
 };
-export const doTheMigration = async ({ itemType = "story", from, itemsToMigrate, migrationConfig, migrationConfigs, to, dryRun, migrateFrom, fromFilePath, fileName, }, config) => {
+export const doTheMigration = async ({ itemType = "story", from, itemsToMigrate, migrationConfig, migrationConfigs, to, dryRun, publish, publishLanguages, migrateFrom, fromFilePath, fileName, }, config) => {
     const preparedMigrationConfigs = migrationConfigs ||
         prepareMigrationConfigs({
             migrationConfig: migrationConfig || [],
@@ -472,6 +480,8 @@ export const doTheMigration = async ({ itemType = "story", from, itemsToMigrate,
         from,
         itemType,
         dryRun,
+        publish,
+        publishLanguages,
         migrateFrom,
         fromFilePath,
         pipelineResult,
@@ -489,11 +499,23 @@ export const doTheMigration = async ({ itemType = "story", from, itemsToMigrate,
         return;
     }
     let writeResults = [];
+    let resolvedPublishLanguages;
     if (itemType === "story") {
+        if (publish && publishLanguages !== undefined) {
+            resolvedPublishLanguages =
+                await managementApi.stories.resolvePublishLanguageCodes(publishLanguages, {
+                    ...config,
+                    spaceId: to,
+                });
+        }
         writeResults = await managementApi.stories.updateStories({
             stories: pipelineResult.changedItems,
             spaceId: to,
-            options: { publish: false },
+            options: {
+                publish: Boolean(publish),
+                publishLanguages: resolvedPublishLanguages,
+                preservePublishState: Boolean(publish),
+            },
         }, config);
     }
     else if (itemType === "preset") {
@@ -504,6 +526,27 @@ export const doTheMigration = async ({ itemType = "story", from, itemsToMigrate,
         }, config);
     }
     const writeSummary = summarizeMutationWriteResults(writeResults);
+    try {
+        await saveMigrationRunLog({
+            artifactBaseName,
+            useDatestamp,
+            from,
+            to,
+            itemType,
+            dryRun,
+            publish,
+            publishLanguages,
+            resolvedPublishLanguages,
+            migrateFrom,
+            fromFilePath,
+            pipelineResult,
+            writeResults,
+            writeSummary,
+        }, config);
+    }
+    catch (error) {
+        Logger.warning(`[MIGRATION] Could not write migration run log: ${error instanceof Error ? error.message : String(error)}`);
+    }
     if (writeSummary.failed === 0) {
         Logger.success(`[MIGRATION] Update complete. ${writeSummary.successful}/${writeSummary.total} ${itemType}(s) updated successfully.`);
         return;
@@ -527,7 +570,7 @@ const saveBackupToFile = async ({ itemType, res, folder, filename }, config) =>
         res: res,
     }, config);
 };
-export const migrateProvidedComponentsDataInStories = async ({ itemType, migrationConfig, migrateFrom, from, to, componentsToMigrate, filters, dryRun, fromFilePath, fileName, preparedMigrationConfigs, migrationComponentAliases, migrationComponentOverrides, }, config) => {
+export const migrateProvidedComponentsDataInStories = async ({ itemType, migrationConfig, migrateFrom, from, to, componentsToMigrate, filters, dryRun, publish, publishLanguages, fromFilePath, fileName, preparedMigrationConfigs, migrationComponentAliases, migrationComponentOverrides, }, config) => {
     const resolvedMigrationConfigs = preparedMigrationConfigs ||
         prepareMigrationConfigs({
             migrationConfig,
@@ -562,6 +605,8 @@ export const migrateProvidedComponentsDataInStories = async ({ itemType, migrati
         from,
         to,
         dryRun,
+        publish,
+        publishLanguages,
         migrateFrom,
         fromFilePath,
         fileName,

package/dist/api/data-migration/migration-run-log.d.ts

@@ -0,0 +1,77 @@
+import type { MigrateFrom, MigrationPipelineResult } from "./component-data-migration.js";
+import type { MutationWriteResult, MutationWriteSummary } from "./write-summary.js";
+import type { PublishLanguagesOption } from "../stories/stories.types.js";
+import type { RequestBaseConfig } from "../utils/request.js";
+type MigrationRunLogEvent = "update_success" | "update_failed" | "publish_success" | "publish_failed" | "publish_skipped" | "migration_write_summary";
+export interface MigrationRunLogRecord {
+    timestamp: string;
+    event: MigrationRunLogEvent;
+    runId: string;
+    itemType: "story" | "preset";
+    source: {
+        migrateFrom: MigrateFrom;
+        from: string;
+        fromFilePath: string | null;
+    };
+    target: {
+        to: string;
+    };
+    writeMode: "publish" | "save";
+    publishLanguages?: {
+        requested?: PublishLanguagesOption;
+        resolved?: string[];
+    };
+    dryRun: boolean;
+    migrationConfigs: string[];
+    totalItems: number;
+    totalChangedItems: number;
+    writeSummary?: {
+        total: number;
+        successful: number;
+        failed: number;
+        failedItems: Array<{
+            id?: number | string;
+            name?: string;
+            slug?: string;
+            spaceId?: string;
+            status?: number | string;
+            response?: string | null;
+            stage?: "update" | "publish";
+            sourcePublishState?: string;
+            publishSkippedReason?: string;
+        }>;
+    };
+    item?: {
+        index: number;
+        id?: number | string;
+        name?: string;
+        slug?: string;
+        spaceId?: string;
+    };
+    status?: number | string | null;
+    response?: string | null;
+    stage?: "update" | "publish";
+    sourcePublishState?: string;
+    publishSkippedReason?: string;
+    error?: unknown;
+}
+interface SaveMigrationRunLogArgs {
+    artifactBaseName: string;
+    useDatestamp: boolean;
+    from: string;
+    to: string;
+    itemType: "story" | "preset";
+    dryRun?: boolean;
+    publish?: boolean;
+    publishLanguages?: PublishLanguagesOption;
+    resolvedPublishLanguages?: string[];
+    migrateFrom: MigrateFrom;
+    fromFilePath?: string;
+    pipelineResult: MigrationPipelineResult;
+    writeResults: PromiseSettledResult<MutationWriteResult>[];
+    writeSummary: MutationWriteSummary;
+}
+export declare const buildMigrationRunLogRecords: ({ from, to, itemType, dryRun, publish, publishLanguages, resolvedPublishLanguages, migrateFrom, fromFilePath, pipelineResult, writeResults, writeSummary, }: Omit<SaveMigrationRunLogArgs, "artifactBaseName" | "useDatestamp">) => MigrationRunLogRecord[];
+export declare const recordsToJsonl: (records: MigrationRunLogRecord[]) => string;
+export declare const saveMigrationRunLog: (args: SaveMigrationRunLogArgs, config: RequestBaseConfig) => Promise<void>;
+export {};