@dinoxx/dinox-cli 1.0.22 → 1.1.0

package/dist/commands/notes/descriptors.js

@@ -1,10 +1,29 @@
 import { registerCommandGroup } from '../descriptor/register.js';
 import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { WRITE_DURABILITY_OPTION } from '../writeDurability.js';
 import { runNoteCreate, runNoteDelete, runNoteDetail, runNoteGet, runNoteMove, runNotePreview, runNoteSearch, runNoteStar, runNoteTag, runNoteUnstar, runNoteUpdate, } from './actions.js';
 import { runNoteBulk as runNoteBulkAction } from './bulk.js';
 import { runNoteContentRead, runNotePatch } from './contentPatchCommand.js';
 import { runNoteExport } from './export.js';
 const NOTE_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+const NOTE_WRITE_RECEIPT_FIELDS = [
+    'durability',
+    'upload_queue_remaining',
+    'version',
+    'updated_at',
+    'content_hash',
+    'changed',
+    'stale',
+];
+const NOTE_BATCH_WRITE_RECEIPT_FIELDS = [
+    'durability',
+    'upload_queue_remaining',
+    'results.version',
+    'results.updated_at',
+    'results.content_hash',
+    'results.changed',
+    'stale',
+];
 export const noteCommandGroup = {
     name: 'note',
     description: 'Manage notes',
@@ -161,6 +180,7 @@ export const noteCommandGroup = {
                 { flags: '--type <note|crawl>', description: 'Note type: note or crawl', type: 'string', defaultValue: 'crawl', enum: ['note', 'crawl'] },
                 { flags: '--tags <string|@file>', description: 'Tag list (JSON array or comma/newline-separated)', type: 'string' },
                 { flags: '--boxes <string|@file>', description: 'Box paths or unique names (JSON array or comma/newline-separated)', type: 'string' },
+                WRITE_DURABILITY_OPTION,
                 { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
             ],
             schema: {
@@ -170,10 +190,10 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Creation acknowledgement with the new note id',
-                    fields: ['id', 'stale'],
+                    summary: 'Creation acknowledgement with write durability, queue state, and note revision receipt',
+                    fields: ['id', ...NOTE_WRITE_RECEIPT_FIELDS],
                 },
-                examples: ['dino note create --title "Weekly note" --content @/tmp/note.md --type note --format json'],
+                examples: ['dino note create --title "Weekly note" --content @/tmp/note.md --type note --durability uploaded --format json'],
             },
             action: runNoteCreate,
         },
@@ -186,6 +206,7 @@ export const noteCommandGroup = {
                 { flags: '--tags <string|@file>', description: 'Replace the entire tag list; use [] to clear all tags', type: 'string' },
                 { flags: '--boxes <string|@file>', description: 'Replace the entire box list; use [] to clear all boxes', type: 'string' },
                 { flags: '--starred <true|false>', description: 'Replace the starred state', type: 'string', enum: ['true', 'false'] },
+                WRITE_DURABILITY_OPTION,
                 { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
             ],
             schema: {
@@ -195,8 +216,8 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Explicit-id full metadata replacement result with per-note status',
-                    fields: ['total', 'updatedCount', 'results', 'stale'],
+                    summary: 'Explicit-id full metadata replacement result with per-note write receipts',
+                    fields: ['total', 'updatedCount', 'results', ...NOTE_BATCH_WRITE_RECEIPT_FIELDS],
                 },
                 examples: [
                     'dino note update <id> --tags "work,ai" --format json --dry-run',
@@ -214,6 +235,7 @@ export const noteCommandGroup = {
                 { flags: '--add <string|@file>', description: 'Tags to add without removing existing tags', type: 'string' },
                 { flags: '--remove <string|@file>', description: 'Tags to remove while preserving the rest', type: 'string' },
                 { flags: '--replace <string|@file>', description: 'Replace the entire tag list; use [] to clear all tags', type: 'string' },
+                WRITE_DURABILITY_OPTION,
                 { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
             ],
             schema: {
@@ -223,8 +245,8 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Explicit-id incremental tag organization result with per-note status',
-                    fields: ['field', 'operation', 'total', 'updatedCount', 'results', 'stale'],
+                    summary: 'Explicit-id incremental tag organization result with per-note write receipts',
+                    fields: ['field', 'operation', 'total', 'updatedCount', 'results', ...NOTE_BATCH_WRITE_RECEIPT_FIELDS],
                 },
                 examples: [
                     'dino note tag <id> --add "AI,work" --format json --dry-run',
@@ -242,6 +264,7 @@ export const noteCommandGroup = {
                 { flags: '--add <string|@file>', description: 'Box paths or unique names to add without removing existing boxes', type: 'string' },
                 { flags: '--remove <string|@file>', description: 'Box paths or unique names to remove while preserving the rest', type: 'string' },
                 { flags: '--replace <string|@file>', description: 'Replace the entire box list; use [] to clear all boxes', type: 'string' },
+                WRITE_DURABILITY_OPTION,
                 { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
             ],
             schema: {
@@ -251,8 +274,8 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Explicit-id incremental box organization result with per-note status',
-                    fields: ['field', 'operation', 'total', 'updatedCount', 'results', 'stale'],
+                    summary: 'Explicit-id incremental box organization result with per-note write receipts',
+                    fields: ['field', 'operation', 'total', 'updatedCount', 'results', ...NOTE_BATCH_WRITE_RECEIPT_FIELDS],
                 },
                 examples: [
                     'dino note move <id> --add "Work/Inbox" --format json --dry-run',
@@ -274,6 +297,7 @@ export const noteCommandGroup = {
                 { flags: '--content <string|@file>', description: 'Markdown content to insert', type: 'string' },
                 { flags: '--read-token <token>', description: 'Required for real writes; returned by note content-read', type: 'string' },
                 { flags: '--allow-protected-replace', description: 'Allow replace operations to affect media, table, container, or unknown blocks after reviewing content-read output', type: 'boolean' },
+                WRITE_DURABILITY_OPTION,
                 { flags: '--dry-run', description: 'Preview the patch without writing', type: 'boolean' },
             ],
             schema: {
@@ -283,8 +307,8 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Structured content edit result with content hashes, block context, and synchronized derived metadata',
-                    fields: ['noteId', 'title', 'operation', 'changed', 'saved', 'beforeHash', 'afterHash', 'target', 'derived', 'stale'],
+                    summary: 'Structured content edit result with content hashes, block context, synchronized derived metadata, and write receipt',
+                    fields: ['noteId', 'title', 'operation', 'content_changed', 'saved', 'beforeHash', 'afterHash', 'target', 'derived', ...NOTE_WRITE_RECEIPT_FIELDS],
                 },
                 examples: [
                     'dino note content-read <id> --format json',
@@ -313,6 +337,7 @@ export const noteCommandGroup = {
                 { flags: '--box-replace <string|@file>', description: 'Replace the entire box list on every matched note; use [] to clear all boxes', type: 'string' },
                 { flags: '--expected-count <n>', description: 'Required for real writes; must equal the current matched note count', type: 'number' },
                 { flags: '--confirm', description: 'Required for real writes after reviewing a dry run', type: 'boolean' },
+                WRITE_DURABILITY_OPTION,
                 { flags: '--dry-run', description: 'Preview matched targets and changes without executing', type: 'boolean' },
             ],
             schema: {
@@ -322,8 +347,8 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Filter-based bulk metadata organization result with applied filters and per-note status',
-                    fields: ['field', 'operation', 'total', 'updatedCount', 'filters', 'results', 'stale'],
+                    summary: 'Filter-based bulk metadata organization result with applied filters and per-note write receipts',
+                    fields: ['field', 'operation', 'total', 'updatedCount', 'filters', 'results', ...NOTE_BATCH_WRITE_RECEIPT_FIELDS],
                 },
                 examples: [
                     'dino note bulk --tags "Inbox" --tag-add "AI" --format json --dry-run',
@@ -336,7 +361,10 @@ export const noteCommandGroup = {
             name: 'delete',
             description: 'Soft-delete a note by setting is_del=1',
             arguments: [{ syntax: '<id>', description: 'Note id' }],
-            options: [{ flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' }],
+            options: [
+                WRITE_DURABILITY_OPTION,
+                { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
+            ],
             schema: {
                 path: 'note.delete',
                 risk: 'high-risk-write',
@@ -344,8 +372,8 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Deletion acknowledgement',
-                    fields: ['id', 'stale'],
+                    summary: 'Deletion acknowledgement with write durability and note revision receipt',
+                    fields: ['id', ...NOTE_WRITE_RECEIPT_FIELDS],
                 },
                 examples: ['dino note delete <id> --format json'],
             },
@@ -357,6 +385,7 @@ export const noteCommandGroup = {
             arguments: [{ syntax: '[id]', description: 'Optional note id for single-note update' }],
             options: [
                 { flags: '--ids <string|@file>', description: 'Batch note ids (JSON array or comma/newline-separated)', type: 'string' },
+                WRITE_DURABILITY_OPTION,
                 { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
             ],
             schema: {
@@ -366,8 +395,8 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Mutation result with per-note starred status',
-                    fields: ['total', 'updatedCount', 'results', 'stale'],
+                    summary: 'Mutation result with per-note starred status and write receipts',
+                    fields: ['total', 'updatedCount', 'results', ...NOTE_BATCH_WRITE_RECEIPT_FIELDS],
                 },
                 examples: ['dino note star <id> --format json --dry-run'],
             },
@@ -379,6 +408,7 @@ export const noteCommandGroup = {
             arguments: [{ syntax: '[id]', description: 'Optional note id for single-note update' }],
             options: [
                 { flags: '--ids <string|@file>', description: 'Batch note ids (JSON array or comma/newline-separated)', type: 'string' },
+                WRITE_DURABILITY_OPTION,
                 { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
             ],
             schema: {
@@ -388,8 +418,8 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Mutation result with per-note starred status',
-                    fields: ['total', 'updatedCount', 'results', 'stale'],
+                    summary: 'Mutation result with per-note starred status and write receipts',
+                    fields: ['total', 'updatedCount', 'results', ...NOTE_BATCH_WRITE_RECEIPT_FIELDS],
                 },
                 examples: ['dino note unstar <id> --format json --dry-run'],
             },

package/dist/commands/notes/dryRun.d.ts

@@ -16,6 +16,7 @@ export declare function buildNoteUpdateDryRunPreview(args: {
     db: AbstractPowerSyncDatabase;
     config: ResolvedDinoxConfig;
     offline: boolean;
+    userId?: string;
     ids: string[];
     tagsInput?: string[];
     zettelBoxNames?: string[];

package/dist/commands/notes/dryRun.js

@@ -1,7 +1,7 @@
 import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
 import { canonicalizeBidlinksInMarkdown } from '../../utils/bidlinkCanonicalization.js';
 import { DinoxError } from '../../utils/errors.js';
-import { assertNotesUpdatable, getNoteDetails, parseStoredTags, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForUpdate, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
+import { assertNotesUpdatable, getNoteDetails, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForUpdate, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
 function normalizeDistinctStrings(values) {
     return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
 }
@@ -21,15 +21,12 @@ function buildExecutionWarnings(config, offline) {
     if (offline) {
         warnings.push('Execution would run in offline mode and only use the local cache.');
     }
-    if (!offline && !config.powersync.uploadBaseUrl) {
-        warnings.push('Execution would be local-only because powersync.uploadBaseUrl is unset.');
-    }
     return warnings;
 }
 export async function buildNoteCreateDryRunPreview(args) {
     const canonicalContentMd = await canonicalizeBidlinksInMarkdown(args.db, args.contentMd, args.userId);
     const { contentText } = convertMarkdownToNoteContent(canonicalContentMd);
-    const tags = await validateTagsForCreate(args.db, args.tagsInput);
+    const tags = await validateTagsForCreate(args.db, args.tagsInput, args.userId);
     await resolveZettelBoxIdsForCreate(args.db, args.zettelBoxNames);
     return {
         dry_run: true,
@@ -59,14 +56,14 @@ export async function buildNoteCreateDryRunPreview(args) {
 export async function buildNoteUpdateDryRunPreview(args) {
     await assertNotesUpdatable(args.db, args.ids);
     const nextTags = Array.isArray(args.tagsInput)
-        ? await validateTagsForUpdate(args.db, args.tagsInput)
+        ? await validateTagsForUpdate(args.db, args.tagsInput, args.userId ?? '')
         : undefined;
     if (Array.isArray(args.zettelBoxNames)) {
         await resolveZettelBoxIdsForUpdate(args.db, args.zettelBoxNames);
     }
     const details = await getNoteDetails(args.db, args.ids);
     const changes = details.map((note) => {
-        const currentTags = parseStoredTags(note.tags);
+        const currentTags = note.tags;
         const nextBoxes = Array.isArray(args.zettelBoxNames) ? normalizeDistinctStrings(args.zettelBoxNames) : note.zettel_boxes;
         const tagsTo = nextTags ?? currentTags;
         const starredTo = typeof args.starred === 'boolean' ? args.starred : note.is_starred;

package/dist/commands/notes/export.d.ts

@@ -14,6 +14,12 @@ export type NoteExportResult = {
 };
 export declare function parseExportFormat(value: unknown): NoteExportFormat;
 export declare function buildExportFileName(note: NoteExportItem, format: NoteExportFormat): string;
+export declare function writeExportFiles(args: {
+    notes: NoteExportItem[];
+    format: NoteExportFormat;
+    outputPath: string;
+    overwrite: boolean;
+}): Promise<NoteExportFile[]>;
 export declare function buildNoteExportStdout(args: {
     notes: NoteExportItem[];
     format: NoteExportFormat;

package/dist/commands/notes/export.js

@@ -22,13 +22,25 @@ export function parseExportFormat(value) {
     }
     throw new DinoxError('--type must be one of: markdown, json');
 }
+function truncateUtf8(value, maxBytes) {
+    let result = '';
+    let bytes = 0;
+    for (const char of value) {
+        const charBytes = Buffer.byteLength(char, 'utf8');
+        if (bytes + charBytes > maxBytes) {
+            break;
+        }
+        result += char;
+        bytes += charBytes;
+    }
+    return result;
+}
 function normalizeFileNamePart(value) {
     const normalized = value
         .normalize('NFKD')
         .replace(/[^\w\u4e00-\u9fff.-]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 80);
-    return normalized || 'untitled';
+        .replace(/^-+|-+$/g, '');
+    return truncateUtf8(normalized, 80).replace(/-+$/g, '') || 'untitled';
 }
 export function buildExportFileName(note, format) {
     const title = normalizeFileNamePart(note.title?.trim() ?? '');
@@ -91,9 +103,10 @@ async function pathExists(filePath) {
     }
 }
 async function resolveOutputTargets(args) {
+    const outputLooksLikeDirectory = /[\\/]$/.test(args.outputPath);
     const outputPath = path.resolve(args.outputPath);
     if (args.notes.length === 1) {
-        if (outputPath.endsWith(path.sep)) {
+        if (outputLooksLikeDirectory) {
             return [{
                     id: args.notes[0].id,
                     path: path.join(outputPath, buildExportFileName(args.notes[0], args.format)),
@@ -130,7 +143,7 @@ async function resolveOutputTargets(args) {
         format: args.format,
     }));
 }
-async function writeExportFiles(args) {
+export async function writeExportFiles(args) {
     const targets = await resolveOutputTargets({
         outputPath: args.outputPath,
         notes: args.notes,
@@ -158,7 +171,14 @@ async function writeExportFiles(args) {
         const content = args.format === 'markdown'
             ? serializeMarkdownExport(note)
             : toJson(note);
-        await fs.writeFile(target.path, content, { encoding: 'utf8', flag: args.overwrite ? 'w' : 'wx' });
+        await fs.writeFile(target.path, content, {
+            encoding: 'utf8',
+            flag: args.overwrite ? 'w' : 'wx',
+            mode: 0o600,
+        });
+        if (process.platform !== 'win32') {
+            await fs.chmod(target.path, 0o600);
+        }
     }
     return targets;
 }

package/dist/commands/notes/metadataMutation.d.ts

@@ -14,6 +14,7 @@ export type NoteMetadataMutationItem = {
     before: string[];
     after: string[];
     changed: boolean;
+    expectedVersion: number;
 };
 export type NoteMetadataMutationPlan = {
     field: NoteMetadataListField;

package/dist/commands/notes/metadataMutation.js

@@ -25,6 +25,10 @@ function sameOrdered(left, right) {
 function keySet(values) {
     return new Set(values.map((value) => value.trim().toLowerCase()).filter(Boolean));
 }
+function normalizeVersion(value) {
+    const parsed = Number(value ?? 0);
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
 function applyListOperation(current, values, operation) {
     const normalizedValues = normalizeDistinct(values);
     if (operation === 'replace') {
@@ -59,7 +63,7 @@ async function loadNoteMetadataState(db, ids) {
         const batch = ids.slice(index, index + chunkSize);
         const placeholders = batch.map(() => '?').join(', ');
         const rows = await db.getAll(`
-      SELECT id, title, tags, zettel_boxes, is_del
+      SELECT id, title, tags, zettel_boxes, is_del, version
       FROM c_note
       WHERE id IN (${placeholders})
       `, batch);
@@ -95,6 +99,7 @@ export async function planNoteMetadataMutation(db, input) {
             before,
             after,
             changed: !sameOrdered(before, after),
+            expectedVersion: normalizeVersion(note.version),
         };
     });
     return {
@@ -116,11 +121,17 @@ export async function applyNoteMetadataMutation(db, plan) {
         const timestamp = nowIsoUtc();
         for (const item of changed) {
             const column = plan.field === 'tags' ? 'tags' : 'zettel_boxes';
-            await tx.execute(`
+            const result = await tx.execute(`
         UPDATE c_note
         SET ${column} = ?, updated_at = ?, version = COALESCE(version, 0) + 1
         WHERE id = ?
-        `, [JSON.stringify(item.after), timestamp, item.id]);
+          AND COALESCE(version, 0) = ?
+          AND (is_del IS NULL OR is_del = 0)
+        RETURNING id
+        `, [JSON.stringify(item.after), timestamp, item.id, item.expectedVersion]);
+            if (result.rows?.length !== 1) {
+                throw new DinoxError(`Note changed concurrently: ${item.id}. Re-run the command with fresh data.`);
+            }
         }
     });
     return plan;

package/dist/commands/notes/repo.d.ts

@@ -36,13 +36,16 @@ export type SearchedNote = {
 export type NoteDetail = {
     id: string;
     created_at: string | null;
+    updated_at: string | null;
     title: string | null;
     type: string | null;
     source: string | null;
-    tags: string | null;
+    tags: string[];
     is_del: number | null;
     is_starred: boolean;
     content_md: string | null;
+    content_text: string | null;
+    content_json: unknown;
     zettel_boxes: string[];
 };
 export type NoteExportItem = {
@@ -90,11 +93,50 @@ export type NotePreview = {
 export type UpdateNoteResult = {
     id: string;
     updated: boolean;
+    changed: string[];
     tags: string[];
     zettelBoxIds: string[];
     is_starred: boolean;
 };
+/**
+ * JSON-safe note-search request. Box *names/paths* are carried (not resolved ids) so the
+ * same payload can be executed either in-process or sent to the daemon over the wire;
+ * id resolution happens inside {@link executeNoteSearch} against whichever db runs it.
+ */
+export type NoteSearchExecuteParams = {
+    keyword: string;
+    includeDeleted: boolean;
+    tagsExpression?: string;
+    createdAtFrom?: string;
+    createdAtTo?: string;
+    starred?: boolean;
+    boxValues: string[];
+    matchEmptyZettelBoxes: boolean;
+    sqlExpression?: string;
+    limit?: number;
+    offset?: number;
+};
+export type NoteSearchExecuteResult = {
+    rows: SearchedNote[];
+    totalCount: number;
+    /** Resolved zettel-box ids, surfaced so callers can echo them in response metadata. */
+    zettelBoxIds: string[];
+};
+/**
+ * Resolve box names to ids and run the note search. Shared by the local command path and
+ * the daemon RPC handler so both produce identical results from one implementation.
+ */
+export declare function executeNoteSearch(db: AbstractPowerSyncDatabase, params: NoteSearchExecuteParams): Promise<NoteSearchExecuteResult>;
 export declare function searchNotes(db: AbstractPowerSyncDatabase, query: string, options: SearchNotesOptions): Promise<SearchedNote[]>;
+type SearchNotesPageOptions = SearchNotesOptions & {
+    limit?: number;
+    offset?: number;
+};
+type SearchNotesPageResult = {
+    rows: SearchedNote[];
+    totalCount: number;
+};
+export declare function searchNotesPage(db: AbstractPowerSyncDatabase, query: string, options: SearchNotesPageOptions): Promise<SearchNotesPageResult>;
 export declare function parseZettelBoxIds(raw: string | null): string[];
 export declare function getNote(db: AbstractPowerSyncDatabase, id: string): Promise<NoteRow | null>;
 export declare function getNoteContext(db: AbstractPowerSyncDatabase, id: string): Promise<NoteContext | null>;
@@ -116,9 +158,9 @@ export declare function createNote(db: AbstractPowerSyncDatabase, input: {
 }): Promise<{
     id: string;
 }>;
-export declare function validateTagsForCreate(db: AbstractPowerSyncDatabase, requestedTags: string[]): Promise<string[]>;
-export declare function validateTagsForUpdate(db: AbstractPowerSyncDatabase, requestedTags: string[]): Promise<string[]>;
-export declare function validateTagsForBulk(db: AbstractPowerSyncDatabase, requestedTags: string[]): Promise<string[]>;
+export declare function validateTagsForCreate(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
+export declare function validateTagsForUpdate(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
+export declare function validateTagsForBulk(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
 export declare function parseStoredTags(raw: string | null): string[];
 export declare function updateNote(db: AbstractPowerSyncDatabase, input: {
     id: string;