@artinstack/migrator 0.1.0

package/dist/index-DQNzrygx.d.ts

@@ -0,0 +1,279 @@
+import { f as NormalizedCategory, k as NormalizedTag, N as NormalizedAsset, i as NormalizedPortfolio, j as NormalizedPost, h as NormalizedPage, P as PortfolioMediaLink, b as EntityKey, g as NormalizedEntity, a as MigrationPlatform, E as EntityBundle, M as MigrationAdapter } from './bundle-BfZqiKV_.js';
+import { Readable } from 'node:stream';
+
+interface RewriteInlineImageRef {
+    originalSrc: string;
+    sourceAssetId?: string;
+}
+interface UploadedAssetRef {
+    targetId: string;
+    publicUrl?: string;
+}
+interface RewriteInlineImagesOptions {
+    resolveAsset: (src: string) => RewriteInlineImageRef | undefined;
+    replaceWith: (ref: RewriteInlineImageRef, uploaded: UploadedAssetRef) => string;
+}
+interface RewriteInlineImagesResult {
+    html: string;
+    referencedSources: string[];
+    unresolved: string[];
+}
+/** Rewrite `<img src>` / `srcset` using uploaded asset targets supplied by the host sink. */
+declare function rewriteInlineImages(html: string, options: RewriteInlineImagesOptions, uploadedBySourceId: Map<string, UploadedAssetRef>): RewriteInlineImagesResult;
+
+interface CreatePostResult {
+    targetId: string;
+    publicPath: string;
+}
+interface CreatePageResult {
+    targetId: string;
+    publicPath: string;
+}
+interface UploadAssetInput {
+    asset: NormalizedAsset;
+    /** Byte stream from source URL or local file. Optional for metadata-only sinks. */
+    body?: Readable | ReadableStream<Uint8Array>;
+    contentLength?: number;
+}
+interface UploadAssetResult {
+    targetId: string;
+    publicUrl?: string;
+}
+interface MigrationRedirect {
+    fromPath: string;
+    toPath: string;
+    statusCode: number;
+}
+interface MigrationProgress {
+    stage: string;
+    progress: number;
+    message?: string;
+}
+/**
+ * Host-implemented write surface (e.g. ArtInStack PlatformMigrationSink).
+ * This package defines the interface only — no Directus or platform imports.
+ */
+interface MigrationSink {
+    createCategory?(category: NormalizedCategory): Promise<{
+        targetId: string;
+    }>;
+    createTag?(tag: NormalizedTag): Promise<{
+        targetId: string;
+    }>;
+    uploadAsset(input: UploadAssetInput): Promise<UploadAssetResult>;
+    createPortfolio?(portfolio: NormalizedPortfolio): Promise<{
+        targetId: string;
+    }>;
+    createPost(post: NormalizedPost): Promise<CreatePostResult>;
+    createPage(page: NormalizedPage): Promise<CreatePageResult>;
+    linkPortfolioMedia?(link: PortfolioMediaLink): Promise<void>;
+    writeRedirect?(redirect: MigrationRedirect): Promise<void>;
+    reportProgress?(progress: MigrationProgress): Promise<void>;
+    /** Optional lookup for idempotent re-runs. */
+    findExisting?(key: EntityKey): Promise<string | undefined>;
+}
+interface ResolvedAssetStream {
+    body: Readable | ReadableStream<Uint8Array>;
+    contentLength?: number;
+}
+interface MigrationRunOptions {
+    sink: MigrationSink;
+    entities: AsyncIterable<NormalizedEntity>;
+    platform: MigrationPlatform;
+    /** Fetch source bytes before uploadAsset; omit for metadata-only sinks. */
+    resolveAssetStream?: (asset: NormalizedAsset) => Promise<ResolvedAssetStream | null>;
+    /** Rewrite post/page HTML after assets are uploaded. */
+    rewriteInlineImages?: RewriteInlineImagesOptions;
+    onEntityProcessed?: (key: EntityKey, result: "done" | "failed" | "skipped", error?: string) => void;
+}
+interface MigrationRunResult {
+    processed: number;
+    failed: number;
+    skipped: number;
+}
+declare const MIGRATION_WRITE_STAGES: readonly ["taxonomy", "assets", "portfolios", "content", "bindings", "redirects"];
+type MigrationWriteStage = (typeof MIGRATION_WRITE_STAGES)[number];
+
+declare function runMigration(options: MigrationRunOptions): Promise<MigrationRunResult>;
+declare function runMigrationFromBundle(bundle: EntityBundle, options: MigrationRunOptions): Promise<MigrationRunResult>;
+
+interface DuplicateSlugConflict {
+    entityType: "post" | "page";
+    slug: string;
+    sourceIds: string[];
+}
+interface MissingFeaturedImageConflict {
+    postSourceId: string;
+    featuredMediaSourceId: string;
+    reason: string;
+}
+interface StaleAssetUrlConflict {
+    sourceId: string;
+    url: string;
+    reason: string;
+}
+interface InvalidHtmlConflict {
+    entityType: "post" | "page";
+    sourceId: string;
+    issues: string[];
+}
+interface UnresolvedInlineImageConflict {
+    postOrPageSourceId: string;
+    src: string;
+}
+interface UnsupportedBlockConflict {
+    entityType: "post" | "page";
+    sourceId: string;
+    blockType: string;
+    blockId?: string;
+}
+interface RedirectLoopConflict {
+    fromPath: string;
+    toPath: string;
+    blocked: boolean;
+}
+interface ConflictReport {
+    duplicatePostSlugs: DuplicateSlugConflict[];
+    duplicatePageSlugs: DuplicateSlugConflict[];
+    missingFeaturedImages: MissingFeaturedImageConflict[];
+    staleAssetUrls: StaleAssetUrlConflict[];
+    invalidHtml: InvalidHtmlConflict[];
+    unresolvedInlineImages: UnresolvedInlineImageConflict[];
+    unsupportedBlocks: UnsupportedBlockConflict[];
+    redirectLoops: RedirectLoopConflict[];
+}
+declare function emptyConflictReport(): ConflictReport;
+declare function analyzeConflicts(bundle: EntityBundle, options?: {
+    staleAssetUrls?: StaleAssetUrlConflict[];
+    redirectLoops?: RedirectLoopConflict[];
+}): ConflictReport;
+declare function hasBlockingConflicts(report: ConflictReport): boolean;
+declare function hasWarnings(report: ConflictReport): boolean;
+declare function buildRedirectMap(bundle: EntityBundle): {
+    fromPath: string;
+    toPath: string;
+    statusCode: number;
+}[];
+declare function detectRedirectLoops(redirects: {
+    fromPath: string;
+    toPath: string;
+}[]): RedirectLoopConflict[];
+
+type MigrationRunMode = "dry-run" | "export" | "sink" | "worker";
+interface MigrationReport {
+    runId: string;
+    platform: MigrationPlatform;
+    mode: MigrationRunMode;
+    startedAt: string;
+    finishedAt: string;
+    summary: {
+        posts: number;
+        pages: number;
+        assets: number;
+        portfolios: number;
+        categories: number;
+        tags: number;
+        storageBytesEstimated?: number;
+    };
+    warnings: string[];
+    errors: string[];
+    conflicts: ConflictReport;
+    redirectMap: {
+        fromPath: string;
+        toPath: string;
+        statusCode: number;
+    }[];
+}
+declare function buildMigrationReport(input: {
+    platform: MigrationPlatform;
+    mode: MigrationRunMode;
+    bundle: EntityBundle;
+    conflicts: ConflictReport;
+    redirectMap: {
+        fromPath: string;
+        toPath: string;
+        statusCode: number;
+    }[];
+    startedAt: Date;
+    finishedAt?: Date;
+    storageBytesEstimated?: number;
+    warnings?: string[];
+    errors?: string[];
+    runId?: string;
+}): MigrationReport;
+
+interface WriteFilesystemOptions {
+    outDir: string;
+    bundle: EntityBundle;
+    conflicts?: ConflictReport;
+    report?: MigrationReport;
+}
+declare function writeFilesystemExport(options: WriteFilesystemOptions): Promise<void>;
+declare function bundleToCombinedJson(bundle: EntityBundle): Record<string, unknown>;
+
+/** Reference MigrationSink that accumulates entities and writes M0 JSON bundles. */
+declare class FilesystemMigrationSink implements MigrationSink {
+    readonly bundle: EntityBundle;
+    readonly portfolioMediaLinks: PortfolioMediaLink[];
+    readonly redirects: MigrationRedirect[];
+    createCategory(category: NormalizedCategory): Promise<{
+        targetId: string;
+    }>;
+    createTag(tag: NormalizedTag): Promise<{
+        targetId: string;
+    }>;
+    uploadAsset(input: UploadAssetInput): Promise<UploadAssetResult>;
+    createPortfolio(portfolio: NormalizedPortfolio): Promise<{
+        targetId: string;
+    }>;
+    createPost(post: NormalizedPost): Promise<CreatePostResult>;
+    createPage(page: NormalizedPage): Promise<CreatePageResult>;
+    linkPortfolioMedia(link: PortfolioMediaLink): Promise<void>;
+    writeRedirect(redirect: MigrationRedirect): Promise<void>;
+    flush(options: WriteFilesystemOptions): Promise<void>;
+}
+declare function createFilesystemMigrationSink(): FilesystemMigrationSink;
+/** Verify sink-produced M2M links match bundle-derived index. */
+declare function portfolioMediaMatchesBundle(sink: FilesystemMigrationSink): boolean;
+
+interface DryRunOptions {
+    adapter: MigrationAdapter;
+    input: unknown;
+    platform: MigrationPlatform;
+    offlineStorageEstimate?: boolean;
+    fetchFn?: typeof fetch;
+}
+interface DryRunResult {
+    bundle: EntityBundle;
+    conflicts: ConflictReport;
+    report: MigrationReport;
+    exitCode: 0 | 1 | 2;
+}
+declare function runDryRun(options: DryRunOptions): Promise<DryRunResult>;
+
+declare const FALLBACK_ASSET_BYTES: number;
+interface AssetSizeResult {
+    sourceId: string;
+    url: string;
+    bytes: number;
+    source: "head" | "fallback";
+    error?: string;
+}
+interface StorageEstimate {
+    totalBytes: number;
+    assets: AssetSizeResult[];
+}
+interface EstimateStorageOptions {
+    assets: NormalizedAsset[];
+    /** When true, skip network and use fallback for all assets. */
+    offline?: boolean;
+    fetchFn?: typeof fetch;
+}
+declare function estimateStorage(options: EstimateStorageOptions): Promise<StorageEstimate>;
+declare function staleUrlsFromEstimate(estimate: StorageEstimate): {
+    sourceId: string;
+    url: string;
+    reason: string;
+}[];
+
+export { runMigration as A, runMigrationFromBundle as B, type ConflictReport as C, type DryRunOptions as D, staleUrlsFromEstimate as E, FALLBACK_ASSET_BYTES as F, writeFilesystemExport as G, MIGRATION_WRITE_STAGES as M, type RewriteInlineImageRef as R, type StorageEstimate as S, type UploadAssetInput as U, type WriteFilesystemOptions as W, type DryRunResult as a, FilesystemMigrationSink as b, type MigrationRedirect as c, type MigrationReport as d, type MigrationRunMode as e, type MigrationRunOptions as f, type MigrationRunResult as g, type MigrationSink as h, type MigrationWriteStage as i, type RewriteInlineImagesOptions as j, type RewriteInlineImagesResult as k, type UploadAssetResult as l, type UploadedAssetRef as m, analyzeConflicts as n, buildMigrationReport as o, buildRedirectMap as p, bundleToCombinedJson as q, createFilesystemMigrationSink as r, detectRedirectLoops as s, emptyConflictReport as t, estimateStorage as u, hasBlockingConflicts as v, hasWarnings as w, portfolioMediaMatchesBundle as x, rewriteInlineImages as y, runDryRun as z };

package/dist/index.d.ts

@@ -0,0 +1,336 @@
+import { M as MigrationAdapter, a as MigrationPlatform } from './bundle-BfZqiKV_.js';
+export { A as AdapterContext, B as BundleCounts, E as EntityBundle, b as EntityKey, c as EntityType, d as MigrationCursor, N as NormalizedAsset, e as NormalizedAssetExif, f as NormalizedCategory, g as NormalizedEntity, h as NormalizedPage, i as NormalizedPortfolio, j as NormalizedPost, k as NormalizedTag, P as PortfolioMediaLink, l as PublishStatus, S as SourceMetadata, V as ValidationIssue, m as ValidationResult, n as bundleCounts, o as collectEntities, p as emptyBundle, q as entityKey } from './bundle-BfZqiKV_.js';
+export { EntityState, MigrationCheckpoint, TrackedEntity, buildPortfolioMediaLinks, isTerminalState, shouldProcessEntity } from './normalizer/index.js';
+export { C as ConflictReport, D as DryRunOptions, a as DryRunResult, F as FALLBACK_ASSET_BYTES, b as FilesystemMigrationSink, M as MIGRATION_WRITE_STAGES, c as MigrationRedirect, d as MigrationReport, e as MigrationRunMode, f as MigrationRunOptions, g as MigrationRunResult, h as MigrationSink, i as MigrationWriteStage, R as RewriteInlineImageRef, j as RewriteInlineImagesOptions, k as RewriteInlineImagesResult, S as StorageEstimate, U as UploadAssetInput, l as UploadAssetResult, m as UploadedAssetRef, W as WriteFilesystemOptions, n as analyzeConflicts, o as buildMigrationReport, p as buildRedirectMap, q as bundleToCombinedJson, r as createFilesystemMigrationSink, s as detectRedirectLoops, t as emptyConflictReport, u as estimateStorage, v as hasBlockingConflicts, w as hasWarnings, x as portfolioMediaMatchesBundle, y as rewriteInlineImages, z as runDryRun, A as runMigration, B as runMigrationFromBundle, E as staleUrlsFromEstimate, G as writeFilesystemExport } from './index-DQNzrygx.js';
+import { z } from 'zod';
+import 'node:stream';
+
+declare const wordpressAdapter: MigrationAdapter;
+
+/** Flat relational dump (Folders / Albums / Images tables). */
+interface SmugMugFlatFolder {
+    sourceId: string;
+    name: string;
+    parentSourceId?: string;
+    slug?: string;
+    description?: string;
+}
+interface SmugMugFlatAlbum {
+    sourceId: string;
+    name: string;
+    parentSourceId?: string;
+    slug?: string;
+    description?: string;
+    url?: string;
+}
+interface SmugMugFlatImage {
+    sourceId: string;
+    portfolioSourceId: string;
+    sort?: number;
+    fileName?: string;
+    originalUrl?: string;
+    caption?: string;
+    keywords?: string[];
+    exif?: {
+        iso?: number | string;
+        aperture?: number | string;
+        shutter?: string;
+        focalLength?: number | string;
+    };
+}
+interface SmugMugFlatExport {
+    exportVersion: string | number;
+    exportedAt?: string;
+    Folders: SmugMugFlatFolder[];
+    Albums: SmugMugFlatAlbum[];
+    Images: SmugMugFlatImage[];
+}
+
+declare const SMUGMUG_API_BASE = "https://api.smugmug.com/api/v2";
+declare const SMUGMUG_OAUTH_ENDPOINTS: {
+    readonly requestToken: "https://api.smugmug.com/services/oauth/1.0a/getRequestToken";
+    readonly authorize: "https://api.smugmug.com/services/oauth/1.0a/authorize";
+    readonly accessToken: "https://api.smugmug.com/services/oauth/1.0a/getAccessToken";
+};
+declare const smugMugCredentialsSchema: z.ZodObject<{
+    consumerKey: z.ZodString;
+    consumerSecret: z.ZodString;
+    accessToken: z.ZodString;
+    accessTokenSecret: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    consumerKey: string;
+    consumerSecret: string;
+    accessToken: string;
+    accessTokenSecret: string;
+}, {
+    consumerKey: string;
+    consumerSecret: string;
+    accessToken: string;
+    accessTokenSecret: string;
+}>;
+type SmugMugCredentials = z.infer<typeof smugMugCredentialsSchema>;
+declare const smugMugClientOptionsSchema: z.ZodObject<{
+    credentials: z.ZodObject<{
+        consumerKey: z.ZodString;
+        consumerSecret: z.ZodString;
+        accessToken: z.ZodString;
+        accessTokenSecret: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        consumerKey: string;
+        consumerSecret: string;
+        accessToken: string;
+        accessTokenSecret: string;
+    }, {
+        consumerKey: string;
+        consumerSecret: string;
+        accessToken: string;
+        accessTokenSecret: string;
+    }>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryBaseDelayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetryDelayMs: z.ZodDefault<z.ZodNumber>;
+    requestIntervalMs: z.ZodDefault<z.ZodNumber>;
+    fetchImpl: z.ZodOptional<z.ZodType<typeof fetch, z.ZodTypeDef, typeof fetch>>;
+}, "strip", z.ZodTypeAny, {
+    maxRetries: number;
+    retryBaseDelayMs: number;
+    maxRetryDelayMs: number;
+    requestIntervalMs: number;
+    credentials: {
+        consumerKey: string;
+        consumerSecret: string;
+        accessToken: string;
+        accessTokenSecret: string;
+    };
+    pageSize: number;
+    fetchImpl?: typeof fetch | undefined;
+}, {
+    credentials: {
+        consumerKey: string;
+        consumerSecret: string;
+        accessToken: string;
+        accessTokenSecret: string;
+    };
+    maxRetries?: number | undefined;
+    retryBaseDelayMs?: number | undefined;
+    maxRetryDelayMs?: number | undefined;
+    requestIntervalMs?: number | undefined;
+    fetchImpl?: typeof fetch | undefined;
+    pageSize?: number | undefined;
+}>;
+type SmugMugClientOptions = z.input<typeof smugMugClientOptionsSchema>;
+/** Build OAuth 1.0a HMAC-SHA1 signature for a SmugMug API request. */
+declare function signSmugMugOAuthRequest(input: {
+    method: string;
+    url: string;
+    credentials: SmugMugCredentials;
+    oauthParams: Record<string, string>;
+    bodyParams?: Record<string, string>;
+}): string;
+declare function buildSmugMugAuthorizationHeader(input: {
+    method: string;
+    url: string;
+    credentials: SmugMugCredentials;
+    nonce?: string;
+    timestamp?: string;
+    bodyParams?: Record<string, string>;
+}): string;
+declare function readSmugMugCredentialsFromEnv(env?: Record<string, string | undefined>): SmugMugCredentials;
+/** Signed SmugMug API client — recursively discovers folders, albums, and images. */
+declare class SmugMugApiClient {
+    readonly credentials: SmugMugCredentials;
+    readonly pageSize: number;
+    readonly maxRetries: number;
+    readonly retryBaseDelayMs: number;
+    readonly maxRetryDelayMs: number;
+    readonly requestIntervalMs: number;
+    readonly fetchImpl: typeof fetch;
+    private lastRequestAt;
+    constructor(options: SmugMugClientOptions);
+    /** Validate credentials against `GET /user/!authuser`. */
+    validateCredentials(): Promise<{
+        nick?: string;
+        rootNodeUri: string;
+    }>;
+    /** Crawl the authenticated user's node tree into flat export tables for `parse-node.ts`. */
+    crawlExport(): Promise<SmugMugFlatExport>;
+    private getAuthUser;
+    private walkNode;
+    private collectAlbumImages;
+    private paginateNodes;
+    private paginateAlbumImages;
+    private paginate;
+    private requestJson;
+    private requestWithRetry;
+    private throttle;
+}
+
+declare const smugmugAdapter: MigrationAdapter;
+
+/** Squarespace JSON export shape for fixtures and static HTML snapshot migration. */
+interface SquarespaceGalleryItem {
+    id?: string;
+    imageUrl: string;
+    altText?: string;
+    caption?: string;
+}
+interface SquarespaceBlock {
+    id?: string;
+    type: string;
+    html?: string;
+    value?: string;
+    imageUrl?: string;
+    altText?: string;
+    caption?: string;
+    url?: string;
+    label?: string;
+    embedHtml?: string;
+    items?: SquarespaceGalleryItem[];
+}
+interface SquarespacePage {
+    id: string;
+    title: string;
+    slug: string;
+    url?: string;
+    status?: "published" | "draft" | "scheduled";
+    isHomePage?: boolean;
+    seoTitle?: string;
+    seoDescription?: string;
+    contentCss?: string;
+    /** Pre-rendered snapshot when blocks[] is absent. */
+    contentHtml?: string;
+    blocks?: SquarespaceBlock[];
+}
+interface SquarespacePost {
+    id: string;
+    title: string;
+    slug: string;
+    url?: string;
+    excerpt?: string;
+    publishedAt?: string;
+    status?: "published" | "draft" | "scheduled";
+    categorySlugs?: string[];
+    tagSlugs?: string[];
+    featuredImageUrl?: string;
+    seoTitle?: string;
+    seoDescription?: string;
+    contentHtml?: string;
+    blocks?: SquarespaceBlock[];
+}
+interface SquarespaceCategory {
+    id: string;
+    name: string;
+    slug: string;
+}
+interface SquarespaceTag {
+    id: string;
+    name: string;
+    slug: string;
+}
+interface SquarespaceExport {
+    exportVersion: string | number;
+    exportedAt?: string;
+    site?: {
+        url?: string;
+        title?: string;
+    };
+    pages: SquarespacePage[];
+    posts?: SquarespacePost[];
+    categories?: SquarespaceCategory[];
+    tags?: SquarespaceTag[];
+}
+
+declare const SQUARESPACE_JSON_FORMAT: "json-pretty";
+declare const SQUARESPACE_JSON_FORMAT_COMPACT: "json";
+type SquarespaceJsonFormat = typeof SQUARESPACE_JSON_FORMAT | typeof SQUARESPACE_JSON_FORMAT_COMPACT;
+declare const squarespaceClientOptionsSchema: z.ZodObject<{
+    format: z.ZodDefault<z.ZodEnum<["json", "json-pretty"]>>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryBaseDelayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetryDelayMs: z.ZodDefault<z.ZodNumber>;
+    requestIntervalMs: z.ZodDefault<z.ZodNumber>;
+    fetchImpl: z.ZodOptional<z.ZodType<typeof fetch, z.ZodTypeDef, typeof fetch>>;
+}, "strip", z.ZodTypeAny, {
+    format: "json-pretty" | "json";
+    maxRetries: number;
+    retryBaseDelayMs: number;
+    maxRetryDelayMs: number;
+    requestIntervalMs: number;
+    fetchImpl?: typeof fetch | undefined;
+}, {
+    format?: "json-pretty" | "json" | undefined;
+    maxRetries?: number | undefined;
+    retryBaseDelayMs?: number | undefined;
+    maxRetryDelayMs?: number | undefined;
+    requestIntervalMs?: number | undefined;
+    fetchImpl?: typeof fetch | undefined;
+}>;
+type SquarespaceClientOptions = z.input<typeof squarespaceClientOptionsSchema>;
+interface SquarespaceCollectTarget {
+    /** Page or collection URL on the live Squarespace site (without format query). */
+    url: string;
+    /** `collection` paginates `items[]`; `page` fetches a single static page/item. */
+    kind?: "auto" | "page" | "collection";
+    isHomePage?: boolean;
+}
+/** Append Squarespace `?format=json-pretty` (or `json`) to a site URL. */
+declare function buildJsonPrettyUrl(pageUrl: string, format?: SquarespaceJsonFormat): string;
+/** Map one Squarespace `?format=json-pretty` response into export partials. */
+declare function mapJsonPrettyWire(wire: unknown, context?: {
+    fetchedUrl?: string;
+    isHomePage?: boolean;
+}): Partial<SquarespaceExport>;
+/** Fetch json-pretty pages/collections and assemble a canonical export document. */
+declare class SquarespaceCollectionClient {
+    readonly format: SquarespaceJsonFormat;
+    readonly maxRetries: number;
+    readonly retryBaseDelayMs: number;
+    readonly maxRetryDelayMs: number;
+    readonly requestIntervalMs: number;
+    readonly fetchImpl: typeof fetch;
+    private lastRequestAt;
+    constructor(options?: SquarespaceClientOptions);
+    buildJsonPrettyUrl(pageUrl: string): string;
+    fetchWire(url: string): Promise<unknown>;
+    collectExport(targets: SquarespaceCollectTarget[]): Promise<SquarespaceExport>;
+    private collectCollectionPages;
+    private requestWithRetry;
+    private throttle;
+}
+
+declare const squarespaceAdapter: MigrationAdapter;
+
+declare function getAdapter(platform: MigrationPlatform): MigrationAdapter;
+
+interface HtmlToGrapesOptions {
+    /** Map source class names to Grapes component types. */
+    componentMap?: Record<string, string>;
+}
+interface GrapesStyleRule {
+    selectors: string[];
+    style: Record<string, string>;
+}
+interface GrapesComponent {
+    type: string;
+    tagName?: string;
+    attributes?: Record<string, string>;
+    classes?: string[];
+    components?: GrapesComponent[];
+    content?: string;
+    void?: boolean;
+}
+interface GrapesProjectSnapshot {
+    content: GrapesComponent[];
+    styles: GrapesStyleRule[];
+    contentHtml?: string;
+    contentCss?: string;
+}
+
+/** Cheerio HTML walk → Grapes `content` + root `styles`. */
+declare function htmlToGrapes(html: string, options?: HtmlToGrapesOptions): GrapesProjectSnapshot;
+
+/** Parse `<style>` blocks and class rules into Grapes root `styles[]`. */
+declare function cssToStyles(css: string): GrapesStyleRule[];
+
+export { type GrapesComponent, type GrapesProjectSnapshot, type GrapesStyleRule, type HtmlToGrapesOptions, MigrationAdapter, MigrationPlatform, SMUGMUG_API_BASE, SMUGMUG_OAUTH_ENDPOINTS, SQUARESPACE_JSON_FORMAT, SmugMugApiClient, type SmugMugClientOptions, type SmugMugCredentials, type SquarespaceClientOptions, type SquarespaceCollectTarget, SquarespaceCollectionClient, buildJsonPrettyUrl, buildSmugMugAuthorizationHeader, cssToStyles, getAdapter, htmlToGrapes, mapJsonPrettyWire, readSmugMugCredentialsFromEnv, signSmugMugOAuthRequest, smugMugCredentialsSchema, smugmugAdapter, squarespaceAdapter, wordpressAdapter };