@web-to-figma/desktop 1.0.0

package/dist/server/routes/capture.js

@@ -0,0 +1,39 @@
+export function registerCaptureRoutes(app, ctx, captureService) {
+    app.post('/api/artifact/capture', async (request, reply) => {
+        const body = request.body;
+        if (captureService.isBusy()) {
+            return reply.status(409).send({ message: 'Capture already in progress' });
+        }
+        try {
+            const { requestId } = await captureService.startCapture(body.url, body.sizes, body.themes);
+            return reply.status(202).send({ requestId });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Capture failed to start';
+            if (message.includes('Chrome')) {
+                return reply.status(503).send({ message: 'Chrome not available' });
+            }
+            if (message.includes('disk')) {
+                return reply.status(507).send({ message: 'Insufficient disk space' });
+            }
+            return reply.status(500).send({ message });
+        }
+    });
+    app.get('/api/artifact/capture-status', async (request, reply) => {
+        const query = request.query;
+        if (!query.requestId) {
+            return reply.status(400).send({ message: 'Request id is required' });
+        }
+        const status = ctx.captures.getCaptureRequestStatus(query.requestId);
+        if (!status) {
+            return reply.status(404).send({ message: 'Capture request not found' });
+        }
+        return reply.status(200).type('application/json').send(JSON.parse(status));
+    });
+    app.post('/api/artifact/cancel-capture', async (request, reply) => {
+        const body = request.body;
+        ctx.captures.cancelCaptureRequest(body.requestId);
+        captureService.cancel(body.requestId);
+        return reply.status(200).send();
+    });
+}

package/dist/server/routes/captures.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from 'fastify';
+import type { AppContext } from '../context.js';
+export declare function registerCaptureListRoutes(app: FastifyInstance, ctx: AppContext): void;

package/dist/server/routes/captures.js

@@ -0,0 +1,75 @@
+import { LOCAL_USER_ID } from '../../utils.js';
+export function registerCaptureListRoutes(app, ctx) {
+    app.get('/api/artifact/captures', async (request, reply) => {
+        const query = request.query;
+        if (query.collectionExternalId) {
+            const owner = ctx.collections.getCollectionOwner(query.collectionExternalId);
+            if (owner === null) {
+                return reply.status(404).send();
+            }
+            if (owner !== LOCAL_USER_ID) {
+                return reply.status(401).send();
+            }
+        }
+        const limit = parseInt(query.limit ?? '50', 10) || 50;
+        const offset = parseInt(query.offset ?? '0', 10) || 0;
+        return ctx.captures.listCaptures(query.collectionExternalId, limit, offset);
+    });
+    app.get('/api/artifact/capture/:externalId', async (request, reply) => {
+        const params = request.params;
+        const capture = ctx.captures.getCaptureWithExports(params.externalId);
+        if (!capture) {
+            return reply.status(404).send();
+        }
+        return capture;
+    });
+    app.post('/api/artifact/captures', async (request, reply) => {
+        const capture = request.body;
+        capture.userId = LOCAL_USER_ID;
+        if (capture.collectionExternalId) {
+            const owner = ctx.collections.getCollectionOwner(capture.collectionExternalId);
+            if (owner === null) {
+                return reply.status(404).send();
+            }
+            if (owner !== LOCAL_USER_ID) {
+                return reply.status(401).send();
+            }
+        }
+        ctx.captures.saveCapture(capture);
+        return reply.status(200).send();
+    });
+    app.post('/api/artifact/capture-update-collection', async (request, reply) => {
+        const body = request.body;
+        const capture = ctx.captures.getCaptureWithExports(body.captureExternalId);
+        if (!capture) {
+            return reply.status(404).send();
+        }
+        if (capture.userId !== LOCAL_USER_ID) {
+            return reply.status(401).send();
+        }
+        ctx.captures.updateCollectionForCapture(body.captureExternalId, body.collectionExternalId);
+        if (body.collectionIconUrl) {
+            ctx.collections.updateIcon(body.collectionExternalId, body.collectionIconUrl);
+        }
+        const tagIds = body.tagValueIds ?? body.tags ?? [];
+        if (capture.id && tagIds.length) {
+            ctx.captures.assignTags(capture.id, tagIds);
+        }
+        return reply.status(200).send();
+    });
+    app.post('/api/artifact/capture-remove', async (request, reply) => {
+        const body = request.body;
+        const capture = ctx.captures.getCaptureWithExports(body.captureExternalId);
+        if (!capture) {
+            return reply.status(404).send();
+        }
+        if (capture.userId !== LOCAL_USER_ID) {
+            return reply.status(401).send();
+        }
+        ctx.captures.removeCaptureFromCollection(body.captureExternalId);
+        return reply.status(200).send();
+    });
+    app.get('/api/artifact/tags', async () => {
+        return ctx.tags.getAllTags();
+    });
+}

package/dist/server/routes/collections.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from 'fastify';
+import type { AppContext } from '../context.js';
+export declare function registerCollectionRoutes(app: FastifyInstance, ctx: AppContext): void;

package/dist/server/routes/collections.js

@@ -0,0 +1,41 @@
+import { LOCAL_USER_ID } from '../../utils.js';
+export function registerCollectionRoutes(app, ctx) {
+    app.put('/api/artifact/collections', async (request, reply) => {
+        const collection = request.body;
+        collection.userId = LOCAL_USER_ID;
+        ctx.collections.saveCollection(collection);
+        return reply.status(200).send();
+    });
+    app.post('/api/artifact/collections', async (request, reply) => {
+        const collections = request.body;
+        for (const collection of collections) {
+            collection.userId = LOCAL_USER_ID;
+        }
+        ctx.collections.saveCollections(collections);
+        return reply.status(200).send();
+    });
+    app.get('/api/artifact/collections', async (request, reply) => {
+        const query = request.query;
+        if (query.withMetadata === 'true') {
+            return ctx.collections.listCollectionsWithMetadata();
+        }
+        return ctx.collections.listCollections();
+    });
+    app.delete('/api/artifact/collections', async (request, reply) => {
+        const query = request.query;
+        const collectionExternalId = query.collectionExternalId;
+        if (!collectionExternalId) {
+            return reply.status(400).send({ message: 'Collection id is required' });
+        }
+        const owner = ctx.collections.getCollectionOwner(collectionExternalId);
+        if (owner === null) {
+            return reply.status(404).send();
+        }
+        if (owner !== LOCAL_USER_ID) {
+            return reply.status(401).send();
+        }
+        const replacement = ctx.collections.getDefaultCollectionExternalId();
+        ctx.collections.deleteCollection(collectionExternalId, replacement);
+        return reply.status(200).send();
+    });
+}

package/dist/server/routes/files.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from 'fastify';
+import type { AppContext } from '../context.js';
+export declare function registerFileRoutes(app: FastifyInstance, ctx: AppContext): void;

package/dist/server/routes/files.js

@@ -0,0 +1,18 @@
+import { contentTypeForPath } from '../../utils.js';
+export function registerFileRoutes(app, ctx) {
+    app.get('/files/*', async (request, reply) => {
+        const params = request.params;
+        const relativePath = params['*'];
+        if (!relativePath) {
+            return reply.status(404).send({ message: 'File not found' });
+        }
+        try {
+            const { data, filePath } = ctx.files.readFile(relativePath);
+            reply.header('Cache-Control', 'private, max-age=3600');
+            return reply.type(contentTypeForPath(filePath)).send(data);
+        }
+        catch {
+            return reply.status(404).send({ message: 'File not found' });
+        }
+    });
+}

package/dist/server/routes/health.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function registerHealthRoutes(app: FastifyInstance, port: number): void;

package/dist/server/routes/health.js

@@ -0,0 +1,8 @@
+import { PACKAGE_VERSION } from '../../config.js';
+export function registerHealthRoutes(app, port) {
+    app.get('/health', async () => ({
+        status: 'UP',
+        version: PACKAGE_VERSION,
+        port,
+    }));
+}

package/dist/server/routes/image.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function registerImageRoutes(app: FastifyInstance): void;

package/dist/server/routes/image.js

@@ -0,0 +1,58 @@
+import sharp from 'sharp';
+const MAX_SIZE = 4096;
+export function registerImageRoutes(app) {
+    app.post('/resizeImg', async (request, reply) => {
+        const body = request.body;
+        try {
+            const input = Buffer.from(body.image, 'base64');
+            let pipeline = sharp(input);
+            if (body.width > body.height) {
+                pipeline = pipeline.resize({ width: MAX_SIZE });
+            }
+            else {
+                pipeline = pipeline.resize({ height: MAX_SIZE });
+            }
+            let output;
+            switch (body.type) {
+                case 'jpeg':
+                case 'jpg':
+                    output = await pipeline.jpeg({ quality: 100 }).toBuffer();
+                    break;
+                case 'png':
+                case 'webp':
+                    output = await pipeline.png().toBuffer();
+                    break;
+                default:
+                    return reply.status(400).send({ message: 'Unknown image format' });
+            }
+            return reply.type('text/plain').send(output.toString('base64'));
+        }
+        catch (err) {
+            return reply.status(400).send({ message: err instanceof Error ? err.message : 'Invalid image' });
+        }
+    });
+    app.post('/convertImg', async (request, reply) => {
+        const body = request.body;
+        try {
+            const input = Buffer.from(body.image, 'base64');
+            let pipeline = sharp(input);
+            let output;
+            switch (body.to_type) {
+                case 'jpeg':
+                case 'jpg':
+                    output = await pipeline.jpeg({ quality: 100 }).toBuffer();
+                    break;
+                case 'png':
+                case 'webp':
+                    output = await pipeline.png().toBuffer();
+                    break;
+                default:
+                    return reply.status(400).send({ message: 'Unknown image format' });
+            }
+            return reply.type('text/plain').send(output.toString('base64'));
+        }
+        catch (err) {
+            return reply.status(400).send({ message: err instanceof Error ? err.message : 'Invalid image' });
+        }
+    });
+}

package/dist/server/routes/proxy.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function registerProxyRoutes(app: FastifyInstance): void;

package/dist/server/routes/proxy.js

@@ -0,0 +1,24 @@
+export function registerProxyRoutes(app) {
+    app.get('/proxy', async (request, reply) => {
+        const query = request.query;
+        const remoteUrl = query.url;
+        if (!remoteUrl) {
+            return reply.status(400).send({ message: 'url is required' });
+        }
+        let url = remoteUrl;
+        let first = true;
+        for (const [key, value] of Object.entries(query)) {
+            if (key === 'url' || value === undefined) {
+                continue;
+            }
+            url += `${first ? '?' : '&'}${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+            first = false;
+        }
+        const response = await fetch(url);
+        for (const [key, value] of response.headers.entries()) {
+            reply.header(key, value);
+        }
+        const body = Buffer.from(await response.arrayBuffer());
+        return reply.status(response.status).send(body);
+    });
+}

package/dist/server/routes/upload.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from 'fastify';
+import type { AppContext } from '../context.js';
+export declare function registerUploadRoutes(app: FastifyInstance, ctx: AppContext): void;

package/dist/server/routes/upload.js

@@ -0,0 +1,102 @@
+import { randomUUID } from 'node:crypto';
+import { getMultipartUpload, registerMultipartUpload, removeMultipartUpload, cleanupStaleMultipartUploads, } from '../../storage/fileStore.js';
+export function registerUploadRoutes(app, ctx) {
+    const cleanupInterval = setInterval(() => {
+        const removed = cleanupStaleMultipartUploads(ctx.paths.tmpDir);
+        if (removed > 0) {
+            ctx.logger.info({ removed }, 'multipart_upload_cleanup');
+        }
+    }, 15 * 60 * 1000);
+    cleanupInterval.unref();
+    app.addHook('onClose', async () => {
+        clearInterval(cleanupInterval);
+    });
+    app.post('/api/artifact/upload-url', async (request, reply) => {
+        const body = request.body;
+        const uploadUrl = `${ctx.baseUrl}/api/artifact/local-upload?key=${encodeURIComponent(body.key)}`;
+        const accessUrl = ctx.files.accessUrl(ctx.baseUrl, body.key);
+        return { uploadUrl, accessUrl };
+    });
+    app.post('/api/artifact/multipart-upload-url', async (request, reply) => {
+        const body = request.body;
+        const uploadId = randomUUID();
+        registerMultipartUpload({
+            uploadId,
+            key: body.key,
+            numParts: body.numParts,
+            createdAt: Date.now(),
+        });
+        const uploadUrls = Array.from({ length: body.numParts }, (_, i) => `${ctx.baseUrl}/api/artifact/local-upload-part?uploadId=${encodeURIComponent(uploadId)}` +
+            `&partNumber=${i + 1}`);
+        return {
+            uploadId,
+            uploadUrls,
+            accessUrl: ctx.files.accessUrl(ctx.baseUrl, body.key),
+        };
+    });
+    app.post('/api/artifact/complete-multipart-upload', async (request, reply) => {
+        const body = request.body;
+        const upload = getMultipartUpload(body.uploadId);
+        if (!upload) {
+            return reply.status(404).send({ message: 'Upload not found' });
+        }
+        if (body.parts.length !== upload.numParts) {
+            return reply.status(400).send({ message: 'Part count mismatch' });
+        }
+        try {
+            ctx.files.completeMultipart(body.key, body.uploadId, upload.numParts);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Multipart upload failed';
+            return reply.status(400).send({ message });
+        }
+        removeMultipartUpload(body.uploadId);
+        return reply.status(200).send();
+    });
+    app.put('/api/artifact/local-upload', async (request, reply) => {
+        const query = request.query;
+        if (!query.key) {
+            return reply.status(400).send({ message: 'key is required' });
+        }
+        const data = request.body;
+        if (!Buffer.isBuffer(data)) {
+            return reply.status(400).send({ message: 'Upload body must be raw bytes' });
+        }
+        const contentType = request.headers['content-type'];
+        const contentEncoding = request.headers['content-encoding'];
+        try {
+            ctx.files.writeFile(query.key, data, contentType, contentEncoding ?? null);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Upload failed';
+            return reply.status(400).send({ message });
+        }
+        return reply.status(200).send();
+    });
+    app.put('/api/artifact/local-upload-part', async (request, reply) => {
+        const query = request.query;
+        if (!query.uploadId || !query.partNumber) {
+            return reply.status(400).send({ message: 'uploadId and partNumber are required' });
+        }
+        const upload = getMultipartUpload(query.uploadId);
+        if (!upload) {
+            return reply.status(404).send({ message: 'Upload not found' });
+        }
+        const partNumber = parseInt(query.partNumber, 10);
+        if (!Number.isFinite(partNumber) || partNumber < 1 || partNumber > upload.numParts) {
+            return reply.status(400).send({ message: 'Invalid part number' });
+        }
+        const data = request.body;
+        if (!Buffer.isBuffer(data)) {
+            return reply.status(400).send({ message: 'Upload body must be raw bytes' });
+        }
+        try {
+            ctx.files.writePart(query.uploadId, partNumber, data);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Upload failed';
+            return reply.status(400).send({ message });
+        }
+        return reply.status(200).send();
+    });
+}

package/dist/server/uploadBody.d.ts

@@ -0,0 +1 @@
+export declare function isRawArtifactUploadRequest(method: string, url: string): boolean;

package/dist/server/uploadBody.js

@@ -0,0 +1,5 @@
+export function isRawArtifactUploadRequest(method, url) {
+    const path = url.split('?')[0] ?? url;
+    return (method === 'PUT' &&
+        (path === '/api/artifact/local-upload' || path === '/api/artifact/local-upload-part'));
+}

package/dist/storage/captureRepo.d.ts

@@ -0,0 +1,21 @@
+import type Database from 'better-sqlite3';
+import type { Capture, CaptureUpdate } from '../types.js';
+import type { CollectionRepo } from './collectionRepo.js';
+export declare class CaptureRepo {
+    private readonly db;
+    private readonly collections;
+    constructor(db: Database.Database, collections: CollectionRepo);
+    saveCapture(capture: Capture): number;
+    getCaptureWithExports(externalId: string): Capture | null;
+    listCaptures(collectionExternalId: string | undefined, limit: number, offset: number): Capture[];
+    updateCollectionForCapture(captureExternalId: string, collectionExternalId: string): void;
+    removeCaptureFromCollection(captureExternalId: string): void;
+    assignTags(captureId: number, tagValueIds: number[]): void;
+    getCaptureId(externalId: string): number | null;
+    getCaptureOwner(externalId: string): number | null;
+    saveCaptureRequest(requestId: string, url: string, update: CaptureUpdate): void;
+    getCaptureRequestStatus(requestId: string): string | null;
+    cancelCaptureRequest(requestId: string): void;
+    isCaptureRequestCancelled(requestId: string): boolean;
+    private listExports;
+}

package/dist/storage/captureRepo.js

@@ -0,0 +1,172 @@
+import { LOCAL_USER_ID, marshalString, nowIso } from '../utils.js';
+export class CaptureRepo {
+    db;
+    collections;
+    constructor(db, collections) {
+        this.db = db;
+        this.collections = collections;
+    }
+    saveCapture(capture) {
+        if (!capture.collectionExternalId) {
+            capture.collectionExternalId = this.collections.getDefaultCollectionExternalId();
+        }
+        const now = nowIso();
+        const tx = this.db.transaction(() => {
+            const result = this.db
+                .prepare(`
+                INSERT INTO capture (
+                    created_at, updated_at, external_id, user_id, url,
+                    is_full_page, collection_external_id
+                ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            `)
+                .run(now, now, capture.externalId, capture.userId ?? LOCAL_USER_ID, capture.url, capture.isFullPage ? 1 : 0, capture.collectionExternalId);
+            const captureId = Number(result.lastInsertRowid);
+            const insertExport = this.db.prepare(`
+                INSERT INTO export (
+                    created_at, updated_at, capture_id, theme, size_name,
+                    width, height, url, screenshot_url, thumbnail_url
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `);
+            for (const exp of capture.exports) {
+                insertExport.run(now, now, captureId, exp.theme, exp.sizeName, exp.width, exp.height, exp.url, exp.screenshotUrl ?? '', exp.thumbnailUrl ?? '');
+            }
+            if (capture.exports[0]?.thumbnailUrl) {
+                this.collections.updateIcon(capture.collectionExternalId, capture.exports[0].thumbnailUrl);
+            }
+            return captureId;
+        });
+        return tx();
+    }
+    getCaptureWithExports(externalId) {
+        const row = this.db
+            .prepare(`
+            SELECT id, external_id, user_id, url, is_full_page, collection_external_id
+            FROM capture
+            WHERE external_id = ? AND deleted_at IS NULL
+        `)
+            .get(externalId);
+        if (!row) {
+            return null;
+        }
+        const capture = rowToCapture(row);
+        capture.exports = this.listExports(Number(row.id));
+        return capture;
+    }
+    listCaptures(collectionExternalId, limit, offset) {
+        let query = `
+            SELECT id, external_id, user_id, url, is_full_page, collection_external_id
+            FROM capture
+            WHERE deleted_at IS NULL
+        `;
+        const params = [];
+        if (collectionExternalId) {
+            query += ' AND collection_external_id = ?';
+            params.push(collectionExternalId);
+        }
+        else {
+            query += ' AND user_id = ?';
+            params.push(LOCAL_USER_ID);
+        }
+        query += ' ORDER BY created_at DESC LIMIT ? OFFSET ?';
+        params.push(limit, offset);
+        const rows = this.db.prepare(query).all(...params);
+        const captures = rows.map(rowToCapture);
+        for (const capture of captures) {
+            capture.exports = this.listExports(capture.id);
+        }
+        return captures;
+    }
+    updateCollectionForCapture(captureExternalId, collectionExternalId) {
+        this.db
+            .prepare('UPDATE capture SET collection_external_id = ?, updated_at = ? WHERE external_id = ?')
+            .run(collectionExternalId, nowIso(), captureExternalId);
+    }
+    removeCaptureFromCollection(captureExternalId) {
+        const defaultId = this.collections.getDefaultCollectionExternalId();
+        this.updateCollectionForCapture(captureExternalId, defaultId);
+    }
+    assignTags(captureId, tagValueIds) {
+        if (tagValueIds.length === 0) {
+            return;
+        }
+        const now = nowIso();
+        const insert = this.db.prepare(`
+            INSERT OR IGNORE INTO capture_tag_mapping (created_at, updated_at, capture_id, tag_value_id)
+            VALUES (?, ?, ?, ?)
+        `);
+        const tx = this.db.transaction(() => {
+            for (const tagValueId of tagValueIds) {
+                insert.run(now, now, captureId, tagValueId);
+            }
+        });
+        tx();
+    }
+    getCaptureId(externalId) {
+        const row = this.db
+            .prepare('SELECT id FROM capture WHERE external_id = ? AND deleted_at IS NULL')
+            .get(externalId);
+        return row?.id ?? null;
+    }
+    getCaptureOwner(externalId) {
+        const row = this.db
+            .prepare('SELECT user_id FROM capture WHERE external_id = ? AND deleted_at IS NULL')
+            .get(externalId);
+        return row?.user_id ?? null;
+    }
+    saveCaptureRequest(requestId, url, update) {
+        const now = nowIso();
+        this.db
+            .prepare(`
+            INSERT INTO capture_request (created_at, updated_at, external_id, user_id, url, status)
+            VALUES (?, ?, ?, ?, ?, ?)
+            ON CONFLICT(user_id, external_id) DO UPDATE SET status = excluded.status, updated_at = excluded.updated_at
+        `)
+            .run(now, now, requestId, LOCAL_USER_ID, url, marshalString(update));
+    }
+    getCaptureRequestStatus(requestId) {
+        const row = this.db
+            .prepare('SELECT status FROM capture_request WHERE external_id = ? AND user_id = ?')
+            .get(requestId, LOCAL_USER_ID);
+        return row?.status ?? null;
+    }
+    cancelCaptureRequest(requestId) {
+        this.db
+            .prepare('UPDATE capture_request SET is_cancelled = 1, updated_at = ? WHERE external_id = ? AND user_id = ?')
+            .run(nowIso(), requestId, LOCAL_USER_ID);
+    }
+    isCaptureRequestCancelled(requestId) {
+        const row = this.db
+            .prepare('SELECT is_cancelled FROM capture_request WHERE external_id = ? AND user_id = ?')
+            .get(requestId, LOCAL_USER_ID);
+        return Boolean(row?.is_cancelled);
+    }
+    listExports(captureId) {
+        const rows = this.db
+            .prepare(`
+            SELECT theme, size_name, width, height, url, screenshot_url, thumbnail_url
+            FROM export
+            WHERE capture_id = ? AND deleted_at IS NULL
+        `)
+            .all(captureId);
+        return rows.map((row) => ({
+            theme: row.theme,
+            sizeName: row.size_name,
+            width: row.width,
+            height: row.height,
+            url: row.url,
+            screenshotUrl: row.screenshot_url,
+            thumbnailUrl: row.thumbnail_url,
+        }));
+    }
+}
+function rowToCapture(row) {
+    return {
+        id: row.id,
+        externalId: row.external_id,
+        userId: row.user_id,
+        url: row.url,
+        isFullPage: Boolean(row.is_full_page),
+        collectionExternalId: row.collection_external_id,
+        exports: [],
+    };
+}

package/dist/storage/collectionRepo.d.ts

@@ -0,0 +1,14 @@
+import type Database from 'better-sqlite3';
+import type { Collection, CollectionWithMetadata } from '../types.js';
+export declare class CollectionRepo {
+    private readonly db;
+    constructor(db: Database.Database);
+    saveCollection(collection: Collection): void;
+    saveCollections(collections: Collection[]): void;
+    listCollections(): Collection[];
+    listCollectionsWithMetadata(): CollectionWithMetadata[];
+    getCollectionOwner(externalId: string): number | null;
+    getDefaultCollectionExternalId(): string;
+    deleteCollection(collectionExternalId: string, replacementCollectionId: string): void;
+    updateIcon(externalId: string, iconUrl: string): void;
+}