@dinoxx/dinox-cli 1.0.0

package/dist/config/paths.js

@@ -0,0 +1,39 @@
+import os from 'node:os';
+import path from 'node:path';
+function resolveConfigHome() {
+    if (process.env.DINOX_CONFIG_DIR) {
+        return process.env.DINOX_CONFIG_DIR;
+    }
+    if (process.platform === 'win32') {
+        return process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming');
+    }
+    if (process.platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Application Support');
+    }
+    return process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), '.config');
+}
+function resolveDataHome() {
+    if (process.env.DINOX_DATA_DIR) {
+        return process.env.DINOX_DATA_DIR;
+    }
+    if (process.platform === 'win32') {
+        return process.env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+    }
+    if (process.platform === 'darwin') {
+        // macOS typically stores app data under Application Support.
+        return path.join(os.homedir(), 'Library', 'Application Support');
+    }
+    return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), '.local', 'share');
+}
+export function getConfigDir() {
+    return path.join(resolveConfigHome(), 'dinox');
+}
+export function getConfigFilePath() {
+    return path.join(getConfigDir(), 'config.json');
+}
+export function getDataDir() {
+    return path.join(resolveDataHome(), 'dinox');
+}
+export function getPowerSyncDbPath() {
+    return path.join(getDataDir(), 'powersync.sqlite');
+}

package/dist/config/resolve.d.ts

@@ -0,0 +1,2 @@
+import type { DinoxConfig, ResolvedDinoxConfig } from './types.js';
+export declare function resolveConfig(raw: DinoxConfig): ResolvedDinoxConfig;

package/dist/config/resolve.js

@@ -0,0 +1,56 @@
+import { POWERSYNC_DEFAULT_ENDPOINT, POWERSYNC_DEFAULT_TOKEN_ENDPOINT, POWERSYNC_DEFAULT_UPLOAD_BASE_URL, } from './serviceEndpoints.js';
+const DEFAULT_UPLOAD_V4_PATH = '/powersync/v4/uploadData';
+const DEFAULT_UPLOAD_V2_PATH = '/powersync/v2/uploadData';
+const DEFAULT_SYNC_TIMEOUT_MS = 15_000;
+function nonEmptyString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function parsePositiveInt(value) {
+    if (typeof value !== 'string' && typeof value !== 'number') {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return undefined;
+    }
+    return Math.trunc(parsed);
+}
+export function resolveConfig(raw) {
+    const fileAuth = nonEmptyString(raw.auth?.authorization);
+    const fileUserId = nonEmptyString(raw.auth?.userId);
+    const fileUsername = nonEmptyString(raw.auth?.username ?? undefined) ?? raw.auth?.username ?? undefined;
+    const fileEmail = nonEmptyString(raw.auth?.email ?? undefined) ?? raw.auth?.email ?? undefined;
+    const fileUserInfoSyncedAt = nonEmptyString(raw.auth?.userInfoSyncedAt);
+    const fileTokenEndpoint = nonEmptyString(raw.powersync?.tokenEndpoint);
+    const fileUploadV4Path = nonEmptyString(raw.powersync?.uploadV4Path);
+    const fileUploadV2Path = nonEmptyString(raw.powersync?.uploadV2Path);
+    const fileTimeoutMs = parsePositiveInt(raw.sync?.timeoutMs);
+    const envAuth = nonEmptyString(process.env.DINOX_AUTHORIZATION);
+    const envTokenEndpoint = nonEmptyString(process.env.DINOX_POWERSYNC_TOKEN_ENDPOINT) ?? nonEmptyString(process.env.POWERSYNC_TOKEN_ENDPOINT);
+    const envUploadV4Path = nonEmptyString(process.env.DINOX_POWERSYNC_UPLOAD_V4_PATH);
+    const envUploadV2Path = nonEmptyString(process.env.DINOX_POWERSYNC_UPLOAD_V2_PATH);
+    const envTimeoutMs = parsePositiveInt(process.env.DINOX_SYNC_TIMEOUT_MS);
+    return {
+        auth: {
+            authorization: envAuth ?? fileAuth,
+            userId: fileUserId,
+            username: fileUsername,
+            email: fileEmail,
+            userInfoSyncedAt: fileUserInfoSyncedAt,
+        },
+        powersync: {
+            endpoint: POWERSYNC_DEFAULT_ENDPOINT,
+            tokenEndpoint: envTokenEndpoint ?? fileTokenEndpoint ?? POWERSYNC_DEFAULT_TOKEN_ENDPOINT,
+            uploadBaseUrl: POWERSYNC_DEFAULT_UPLOAD_BASE_URL,
+            uploadV4Path: envUploadV4Path ?? fileUploadV4Path ?? DEFAULT_UPLOAD_V4_PATH,
+            uploadV2Path: envUploadV2Path ?? fileUploadV2Path ?? DEFAULT_UPLOAD_V2_PATH,
+        },
+        sync: {
+            timeoutMs: envTimeoutMs ?? fileTimeoutMs ?? DEFAULT_SYNC_TIMEOUT_MS,
+        },
+    };
+}

package/dist/config/serviceEndpoints.d.ts

@@ -0,0 +1,3 @@
+export declare const POWERSYNC_DEFAULT_ENDPOINT = "https://powersync.dinoai.fun";
+export declare const POWERSYNC_DEFAULT_TOKEN_ENDPOINT = "https://dinoai.chatgo.pro/auth/v2/token";
+export declare const POWERSYNC_DEFAULT_UPLOAD_BASE_URL = "https://dinoai.chatgo.pro";

package/dist/config/serviceEndpoints.js

@@ -0,0 +1,3 @@
+export const POWERSYNC_DEFAULT_ENDPOINT = 'https://powersync.dinoai.fun';
+export const POWERSYNC_DEFAULT_TOKEN_ENDPOINT = 'https://dinoai.chatgo.pro/auth/v2/token';
+export const POWERSYNC_DEFAULT_UPLOAD_BASE_URL = 'https://dinoai.chatgo.pro';

package/dist/config/store.d.ts

@@ -0,0 +1,5 @@
+import type { DinoxConfig } from './types.js';
+export declare function loadConfig(): Promise<DinoxConfig>;
+export declare function saveConfig(config: DinoxConfig): Promise<void>;
+export declare function setConfigValue(keyPath: string, value: unknown): Promise<void>;
+export declare function getConfigValue(keyPath?: string): Promise<unknown>;

package/dist/config/store.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getConfigDir, getConfigFilePath } from './paths.js';
+import { generateId } from '../utils/id.js';
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+async function ensureConfigDir() {
+    const dir = getConfigDir();
+    await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    return dir;
+}
+export async function loadConfig() {
+    const filePath = getConfigFilePath();
+    try {
+        const raw = await fs.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!isPlainObject(parsed)) {
+            return {};
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return {};
+        }
+        throw error;
+    }
+}
+export async function saveConfig(config) {
+    const dir = await ensureConfigDir();
+    const filePath = getConfigFilePath();
+    const tmpPath = path.join(dir, `config.${generateId()}.tmp`);
+    const payload = `${JSON.stringify(config, null, 2)}\n`;
+    // Write config atomically to avoid partial reads.
+    const handle = await fs.open(tmpPath, 'wx', 0o600);
+    try {
+        await handle.writeFile(payload, 'utf8');
+    }
+    finally {
+        await handle.close();
+    }
+    if (process.platform !== 'win32') {
+        // Best-effort: keep the config private.
+        await fs.chmod(tmpPath, 0o600).catch(() => undefined);
+    }
+    await fs.rename(tmpPath, filePath);
+}
+function setDeepValue(target, keyPath, value) {
+    const segments = keyPath.split('.').filter(Boolean);
+    if (segments.length === 0) {
+        return;
+    }
+    let cursor = target;
+    for (let i = 0; i < segments.length - 1; i += 1) {
+        const segment = segments[i];
+        const next = cursor[segment];
+        if (!isPlainObject(next)) {
+            cursor[segment] = {};
+        }
+        cursor = cursor[segment];
+    }
+    cursor[segments[segments.length - 1]] = value;
+}
+function getDeepValue(target, keyPath) {
+    const segments = keyPath.split('.').filter(Boolean);
+    let cursor = target;
+    for (const segment of segments) {
+        if (!isPlainObject(cursor)) {
+            return undefined;
+        }
+        cursor = cursor[segment];
+    }
+    return cursor;
+}
+export async function setConfigValue(keyPath, value) {
+    const config = await loadConfig();
+    setDeepValue(config, keyPath, value);
+    await saveConfig(config);
+}
+export async function getConfigValue(keyPath) {
+    const config = await loadConfig();
+    if (!keyPath) {
+        return config;
+    }
+    return getDeepValue(config, keyPath);
+}

package/dist/config/types.d.ts

@@ -0,0 +1,51 @@
+export type DinoxConfig = {
+    auth?: {
+        /**
+         * Full Authorization header value.
+         * Example: "Bearer <token>".
+         */
+        authorization?: string;
+        /**
+         * Backend user id from /auth/userInfo.
+         */
+        userId?: string;
+        username?: string | null;
+        email?: string | null;
+        userInfoSyncedAt?: string;
+    };
+    powersync?: {
+        /** PowerSync sync service endpoint (downloads/subscriptions). */
+        endpoint?: string;
+        /** Endpoint that exchanges Authorization for PowerSync credentials. */
+        tokenEndpoint?: string;
+        /** Base URL for upload endpoints. */
+        uploadBaseUrl?: string;
+        /** Defaults to /powersync/v4/uploadData */
+        uploadV4Path?: string;
+        /** Defaults to /powersync/v2/uploadData */
+        uploadV2Path?: string;
+    };
+    sync?: {
+        /** Default sync/connect timeout in milliseconds. */
+        timeoutMs?: number;
+    };
+};
+export type ResolvedDinoxConfig = {
+    auth: {
+        authorization?: string;
+        userId?: string;
+        username?: string | null;
+        email?: string | null;
+        userInfoSyncedAt?: string;
+    };
+    powersync: {
+        endpoint: string;
+        tokenEndpoint: string;
+        uploadBaseUrl: string;
+        uploadV4Path: string;
+        uploadV2Path: string;
+    };
+    sync: {
+        timeoutMs: number;
+    };
+};

package/dist/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/dinox.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/dinox.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { createCli } from './cli.js';
+import { isDinoxError } from './utils/errors.js';
+import { printYaml } from './utils/output.js';
+function normalizeArgv(argv) {
+    // pnpm/npm script forwarding can prepend a standalone "--".
+    if (argv[0] === '--') {
+        return argv.slice(1);
+    }
+    return argv;
+}
+async function main() {
+    const program = createCli();
+    const argv = normalizeArgv(process.argv.slice(2));
+    const executable = process.argv[1] ?? 'dino';
+    await program.parseAsync(['node', executable, ...argv]);
+}
+function shouldOutputJson(argv) {
+    return argv.includes('--json');
+}
+function isVerbose(argv) {
+    return argv.includes('--verbose');
+}
+main().catch((error) => {
+    const argv = process.argv;
+    const json = shouldOutputJson(argv);
+    const verbose = isVerbose(argv);
+    const message = error instanceof Error ? error.message : String(error);
+    const name = error instanceof Error ? error.name : 'Error';
+    const stack = error instanceof Error ? error.stack : undefined;
+    const details = isDinoxError(error) ? error.details : undefined;
+    const exitCode = isDinoxError(error) ? error.exitCode : 1;
+    process.exitCode = exitCode;
+    if (json) {
+        printYaml({
+            ok: false,
+            error: {
+                name,
+                message,
+                ...(details !== undefined ? { details } : {}),
+                ...(verbose && stack ? { stack } : {}),
+            },
+        });
+        return;
+    }
+    console.error(message);
+    if (verbose && stack) {
+        console.error(stack);
+    }
+});

package/dist/powersync/connector.d.ts

@@ -0,0 +1,21 @@
+import type { AbstractPowerSyncDatabase, PowerSyncBackendConnector, PowerSyncCredentials } from '@powersync/node';
+export type { PowerSyncCredentials } from '@powersync/node';
+export type CredentialFetcher = () => Promise<PowerSyncCredentials>;
+export type UploadHandler = (database: AbstractPowerSyncDatabase) => Promise<void>;
+/**
+ * Connector that fetches PowerSync credentials from your backend.
+ * This is injectable for testability.
+ */
+export declare class PowerSyncConnector implements PowerSyncBackendConnector {
+    private readonly fetcher;
+    private readonly uploader?;
+    constructor(fetcher: CredentialFetcher, uploader?: UploadHandler | undefined);
+    fetchCredentials(): Promise<PowerSyncCredentials>;
+    uploadData(database: AbstractPowerSyncDatabase): Promise<void>;
+}
+export declare function fetchCredentialsWithAuthorization({ authorization, endpoint, credentialsUrl, signal, }: {
+    authorization: string;
+    endpoint: string;
+    credentialsUrl: string;
+    signal?: AbortSignal;
+}): Promise<PowerSyncCredentials>;

package/dist/powersync/connector.js

@@ -0,0 +1,58 @@
+/**
+ * Connector that fetches PowerSync credentials from your backend.
+ * This is injectable for testability.
+ */
+export class PowerSyncConnector {
+    fetcher;
+    uploader;
+    constructor(fetcher, uploader) {
+        this.fetcher = fetcher;
+        this.uploader = uploader;
+    }
+    async fetchCredentials() {
+        const credentials = await this.fetcher();
+        if (!credentials?.endpoint || !credentials?.token) {
+            throw new Error('PowerSync credentials must include endpoint and token');
+        }
+        return credentials;
+    }
+    async uploadData(database) {
+        if (!this.uploader) {
+            return;
+        }
+        await this.uploader(database);
+    }
+}
+export async function fetchCredentialsWithAuthorization({ authorization, endpoint, credentialsUrl, signal, }) {
+    if (!authorization) {
+        throw new Error('PowerSync credential exchange requires an authorization token');
+    }
+    if (!endpoint) {
+        throw new Error('PowerSync credential exchange requires an endpoint');
+    }
+    if (!credentialsUrl) {
+        throw new Error('PowerSync credential exchange requires a token endpoint');
+    }
+    const response = await fetch(credentialsUrl, {
+        method: 'GET',
+        headers: {
+            Authorization: authorization,
+            'Content-Type': 'application/json',
+        },
+        signal,
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => '');
+        throw new Error(`Received ${response.status} from ${credentialsUrl}: ${errorText}`);
+    }
+    const payload = await response.json().catch(() => null);
+    const token = payload?.token ?? payload?.data?.token ?? null;
+    const endpointFromPayload = payload?.endpoint ?? payload?.data?.endpoint ?? null;
+    if (!token) {
+        throw new Error('PowerSync credential response did not include a token');
+    }
+    return {
+        endpoint: endpointFromPayload ?? endpoint,
+        token,
+    };
+}

package/dist/powersync/runtime.d.ts

@@ -0,0 +1,37 @@
+import { PowerSyncDatabase } from '@powersync/node';
+import type { AbstractPowerSyncDatabase, SyncStatusOptions } from '@powersync/common';
+import type { ResolvedDinoxConfig } from '../config/types.js';
+export type ConnectResult = {
+    db: PowerSyncDatabase;
+    dbPath: string;
+    stale: boolean;
+};
+export declare function getStatusSnapshot(db: AbstractPowerSyncDatabase): {
+    connected: boolean;
+    connecting: boolean;
+    hasSynced: boolean;
+    lastSyncedAt: string | null;
+    dataFlowStatus: {
+        downloading: boolean;
+        uploading: boolean;
+        downloadError?: {
+            name: string;
+            message: string;
+        };
+        uploadError?: {
+            name: string;
+            message: string;
+        };
+    };
+    raw: SyncStatusOptions;
+};
+export declare function openPowerSyncDatabase(): Promise<{
+    db: PowerSyncDatabase;
+    dbPath: string;
+}>;
+export declare function connectPowerSync(args: {
+    config: ResolvedDinoxConfig;
+    offline: boolean;
+    timeoutMs: number;
+}): Promise<ConnectResult>;
+export declare function waitForIdleDataFlow(db: AbstractPowerSyncDatabase, timeoutMs: number): Promise<boolean>;

package/dist/powersync/runtime.js

@@ -0,0 +1,107 @@
+import fs from 'node:fs/promises';
+import { PowerSyncDatabase } from '@powersync/node';
+import { getDataDir, getPowerSyncDbPath } from '../config/paths.js';
+import { DinoxError } from '../utils/errors.js';
+import { AppSchema } from './schema/index.js';
+import { PowerSyncConnector, fetchCredentialsWithAuthorization } from './connector.js';
+import { createPowerSyncUploadHandler } from './uploader.js';
+async function ensureDataDir() {
+    const dir = getDataDir();
+    await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    return dir;
+}
+function createTimeoutSignal(timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    return {
+        signal: controller.signal,
+        cancel: () => clearTimeout(timer),
+    };
+}
+export function getStatusSnapshot(db) {
+    const raw = db.currentStatus?.toJSON?.() ?? {};
+    const lastSyncedAt = raw.lastSyncedAt instanceof Date ? raw.lastSyncedAt.toISOString() : raw.lastSyncedAt ?? null;
+    const dataFlow = raw.dataFlow ?? {};
+    return {
+        connected: Boolean(raw.connected),
+        connecting: Boolean(raw.connecting),
+        hasSynced: Boolean(raw.hasSynced),
+        lastSyncedAt,
+        dataFlowStatus: {
+            downloading: Boolean(dataFlow.downloading),
+            uploading: Boolean(dataFlow.uploading),
+            downloadError: dataFlow.downloadError
+                ? { name: dataFlow.downloadError.name ?? 'Error', message: dataFlow.downloadError.message ?? String(dataFlow.downloadError) }
+                : undefined,
+            uploadError: dataFlow.uploadError
+                ? { name: dataFlow.uploadError.name ?? 'Error', message: dataFlow.uploadError.message ?? String(dataFlow.uploadError) }
+                : undefined,
+        },
+        raw,
+    };
+}
+export async function openPowerSyncDatabase() {
+    await ensureDataDir();
+    const dbPath = getPowerSyncDbPath();
+    const db = new PowerSyncDatabase({
+        schema: AppSchema,
+        database: {
+            dbFilename: dbPath,
+        },
+    });
+    // Ensure initialization errors surface early.
+    await db.init();
+    return { db, dbPath };
+}
+function assertConfigured(config) {
+    if (!config.auth.authorization) {
+        throw new DinoxError('Not logged in. Run: dino auth login <authorization>');
+    }
+}
+export async function connectPowerSync(args) {
+    const { db, dbPath } = await openPowerSyncDatabase();
+    if (args.offline) {
+        return { db, dbPath, stale: true };
+    }
+    assertConfigured(args.config);
+    const uploader = args.config.powersync.uploadBaseUrl
+        ? createPowerSyncUploadHandler({
+            authorization: args.config.auth.authorization,
+            uploadBaseUrl: args.config.powersync.uploadBaseUrl,
+            uploadV4Path: args.config.powersync.uploadV4Path,
+            uploadV2Path: args.config.powersync.uploadV2Path,
+        })
+        : undefined;
+    const connector = new PowerSyncConnector(async () => {
+        return fetchCredentialsWithAuthorization({
+            authorization: args.config.auth.authorization,
+            endpoint: args.config.powersync.endpoint,
+            credentialsUrl: args.config.powersync.tokenEndpoint,
+        });
+    }, uploader);
+    await db.connect(connector);
+    const { signal, cancel } = createTimeoutSignal(args.timeoutMs);
+    try {
+        await db.waitForFirstSync(signal);
+        return { db, dbPath, stale: signal.aborted };
+    }
+    finally {
+        cancel();
+    }
+}
+export async function waitForIdleDataFlow(db, timeoutMs) {
+    const { signal, cancel } = createTimeoutSignal(timeoutMs);
+    try {
+        await db.waitForStatus(status => {
+            const flow = status.dataFlowStatus;
+            return !flow.downloading && !flow.uploading;
+        }, signal);
+        return !signal.aborted;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        cancel();
+    }
+}

package/dist/powersync/schema/content.d.ts

@@ -0,0 +1,76 @@
+import { Table } from '@powersync/common';
+export declare const c_card_box: Table<{
+    id: import("@powersync/common").BaseColumnType<string | null>;
+    name: import("@powersync/common").BaseColumnType<string | null>;
+    type: import("@powersync/common").BaseColumnType<string | null>;
+    cover_url: import("@powersync/common").BaseColumnType<string | null>;
+    prompt: import("@powersync/common").BaseColumnType<string | null>;
+    headers: import("@powersync/common").BaseColumnType<string | null>;
+    priority: import("@powersync/common").BaseColumnType<number | null>;
+    created_at: import("@powersync/common").BaseColumnType<string | null>;
+    updated_at: import("@powersync/common").BaseColumnType<string | null>;
+    extra_data: import("@powersync/common").BaseColumnType<string | null>;
+    user_no: import("@powersync/common").BaseColumnType<string | null>;
+    is_del: import("@powersync/common").BaseColumnType<number | null>;
+    template_id: import("@powersync/common").BaseColumnType<string | null>;
+}>;
+export declare const c_card_note: Table<{
+    id: import("@powersync/common").BaseColumnType<string | null>;
+    box_id: import("@powersync/common").BaseColumnType<string | null>;
+    content: import("@powersync/common").BaseColumnType<string | null>;
+    created_at: import("@powersync/common").BaseColumnType<string | null>;
+    updated_at: import("@powersync/common").BaseColumnType<string | null>;
+    extra_data: import("@powersync/common").BaseColumnType<string | null>;
+    user_no: import("@powersync/common").BaseColumnType<string | null>;
+    is_del: import("@powersync/common").BaseColumnType<number | null>;
+    origin_note_id: import("@powersync/common").BaseColumnType<string | null>;
+    origin_type: import("@powersync/common").BaseColumnType<string | null>;
+    output_type: import("@powersync/common").BaseColumnType<string | null>;
+    is_array: import("@powersync/common").BaseColumnType<number | null>;
+}>;
+export declare const c_cmd: Table<{
+    id: import("@powersync/common").BaseColumnType<string | null>;
+    zone: import("@powersync/common").BaseColumnType<string | null>;
+    type: import("@powersync/common").BaseColumnType<string | null>;
+    cmd: import("@powersync/common").BaseColumnType<string | null>;
+    name: import("@powersync/common").BaseColumnType<string | null>;
+    priority: import("@powersync/common").BaseColumnType<number | null>;
+    is_show: import("@powersync/common").BaseColumnType<number | null>;
+    description: import("@powersync/common").BaseColumnType<string | null>;
+    extra_data: import("@powersync/common").BaseColumnType<string | null>;
+    user_id: import("@powersync/common").BaseColumnType<string | null>;
+    insert_at: import("@powersync/common").BaseColumnType<string | null>;
+    update_at: import("@powersync/common").BaseColumnType<string | null>;
+    is_del: import("@powersync/common").BaseColumnType<number | null>;
+    template_id: import("@powersync/common").BaseColumnType<string | null>;
+    meta_data: import("@powersync/common").BaseColumnType<string | null>;
+    output: import("@powersync/common").BaseColumnType<string | null>;
+    output_param: import("@powersync/common").BaseColumnType<string | null>;
+    category: import("@powersync/common").BaseColumnType<string | null>;
+}>;
+export declare const c_note_template: Table<{
+    id: import("@powersync/common").BaseColumnType<string | null>;
+    content: import("@powersync/common").BaseColumnType<string | null>;
+    name: import("@powersync/common").BaseColumnType<string | null>;
+    priority: import("@powersync/common").BaseColumnType<number | null>;
+    is_show: import("@powersync/common").BaseColumnType<number | null>;
+    extra_data: import("@powersync/common").BaseColumnType<string | null>;
+    user_id: import("@powersync/common").BaseColumnType<string | null>;
+    insert_at: import("@powersync/common").BaseColumnType<string | null>;
+    update_at: import("@powersync/common").BaseColumnType<string | null>;
+    is_del: import("@powersync/common").BaseColumnType<number | null>;
+}>;
+export declare const c_zettel_box: Table<{
+    id: import("@powersync/common").BaseColumnType<string | null>;
+    name: import("@powersync/common").BaseColumnType<string | null>;
+    description: import("@powersync/common").BaseColumnType<string | null>;
+    color: import("@powersync/common").BaseColumnType<string | null>;
+    priority: import("@powersync/common").BaseColumnType<number | null>;
+    is_show: import("@powersync/common").BaseColumnType<number | null>;
+    cover_url: import("@powersync/common").BaseColumnType<string | null>;
+    created_at: import("@powersync/common").BaseColumnType<string | null>;
+    updated_at: import("@powersync/common").BaseColumnType<string | null>;
+    extra_data: import("@powersync/common").BaseColumnType<string | null>;
+    user_no: import("@powersync/common").BaseColumnType<string | null>;
+    is_del: import("@powersync/common").BaseColumnType<number | null>;
+}>;