appwrite-ctl 1.0.0

package/README.md

@@ -0,0 +1,288 @@
+# Appwrite Ctl
+
+A Node.js (ESM) package to manage Appwrite infrastructure via Version Snapshots. Uses the **Appwrite CLI** for schema pull/push operations and the **Appwrite SDK** for data migration scripts.
+
+## Features
+
+- **Version Control for Appwrite Schema**: Manage your `appwrite.config.json` snapshots alongside your code.
+- **CLI-based Snapshots**: Uses `appwrite-cli` pull/push for reliable schema synchronization.
+- **Data Migrations**: Execute TypeScript or JavaScript migration scripts (`up` and `down`) using the Node.js SDK.
+- **State Management**: Tracks applied migrations in a dedicated Appwrite collection (`system.migrations`).
+- **Backup Hooks**: Supports executing external backup commands before migration.
+- **Attribute Polling**: Ensures schema attributes are `available` before running data scripts.
+
+## Installation
+
+```bash
+npm install -g appwrite-ctl
+# or
+npm install --save-dev appwrite-ctl
+```
+
+### From Repository
+
+```bash
+npm install github:bfbechlin/appwrite-ctl
+```
+
+## Prerequisites
+
+- **Node.js**: v18 or higher.
+- **Appwrite CLI**: Installed globally (`npm install -g appwrite-cli`). The tool configures the CLI automatically using API key — no interactive login required.
+- **Environment Variables**:
+
+```env
+APPWRITE_ENDPOINT=https://cloud.appwrite.io/v1
+APPWRITE_PROJECT_ID=your_project_id
+APPWRITE_API_KEY=your_api_key
+BACKUP_COMMAND="docker exec appwrite-mariadb mysqldump ..." # Optional
+```
+
+## Architecture
+
+The tool uses a clear separation of concerns:
+
+| Operation                    | Tool             | Why                                                                          |
+| :--------------------------- | :--------------- | :--------------------------------------------------------------------------- |
+| Schema snapshots (pull/push) | **Appwrite CLI** | Has full serialization/deserialization of schemas via `appwrite.config.json` |
+| Data migrations (up/down)    | **Appwrite SDK** | Provides programmatic access to databases, documents, etc.                   |
+| Migration tracking           | **Appwrite SDK** | Creates/reads documents in the `system.migrations` collection                |
+
+## CLI Usage
+
+```bash
+# Default (uses .env)
+npx appwrite-ctl migrations run
+
+# Custom environment file
+npx appwrite-ctl migrations run --env .env.prod
+```
+
+## Quick Start
+
+### 1. Initialize the Project
+
+```bash
+npx appwrite-ctl init
+```
+
+Creates:
+
+- `appwrite/migration/` directory
+- `appwrite/migration/config.json` configuration file
+
+### 2. Setup System Collection
+
+```bash
+npx appwrite-ctl migrations setup
+```
+
+### 3. Create a Migration
+
+```bash
+npx appwrite-ctl migrations create
+```
+
+This command:
+
+1. Creates `appwrite/migration/vN/` (auto-increments version).
+2. Generates an `index.ts` file with a boilerplate migration script.
+3. Copies the current `appwrite.config.json` from the project root (or pulls from Appwrite via CLI if no local snapshot exists).
+
+**Folder Structure:**
+
+```
+/appwrite
+  schema.md                    <-- Generated by `docs` command
+  /migration
+    config.json
+    /v1
+      index.ts                 <-- Migration logic (SDK)
+      appwrite.config.json     <-- Schema snapshot (CLI format)
+      schema.md                <-- Auto-generated on create/update
+    /v2
+      index.ts
+      appwrite.config.json
+      schema.md
+```
+
+### 4. Edit Migration Logic
+
+```typescript
+import { Migration } from 'appwrite-ctl';
+
+const migration: Migration = {
+  id: 'uuid-generated-id',
+  description: 'Update finance schema',
+  requiresBackup: true,
+
+  up: async ({ client, databases, log }) => {
+    log('Seeding initial data...');
+    await databases.createDocument('db', 'users', 'unique()', {
+      name: 'Admin',
+      role: 'admin',
+    });
+  },
+
+  down: async ({ client, databases, log }) => {
+    // Logic to revert changes
+  },
+};
+
+export default migration;
+```
+
+### 5. Update a Snapshot
+
+After making schema changes in the Appwrite console, update a migration version's snapshot:
+
+```bash
+npx appwrite-ctl migrations update v1
+```
+
+This pulls the current state from Appwrite via CLI and saves it as the version's `appwrite.config.json`.
+
+### 6. Run Migrations
+
+```bash
+npx appwrite-ctl migrations run
+```
+
+The runner performs these steps for each pending version:
+
+1. **Configure CLI**: Sets endpoint, project-id, and API key on appwrite-cli.
+2. **Backup**: Runs `BACKUP_COMMAND` if `requiresBackup` is true.
+3. **Schema Push**: Pushes the version's `appwrite.config.json` via CLI (settings, tables, buckets, teams, topics).
+4. **Polling**: Waits for all schema attributes to become `available` (via SDK).
+5. **Execution**: Runs the `up` function defined in `index.ts` (via SDK).
+6. **Finalization**: Records the migration as applied.
+
+### 7. Check Status
+
+```bash
+npx appwrite-ctl migrations status
+```
+
+### 8. Generate Schema Docs
+
+```bash
+# Generate from latest version → appwrite/schema.md
+npx appwrite-ctl migrations docs
+
+# Generate from a specific version
+npx appwrite-ctl migrations docs v1
+```
+
+Generates a Markdown file with:
+
+- **ER diagrams** (Mermaid) for each database (system database excluded)
+- **Collection details**: columns, types, defaults, indexes, permissions, relationships
+- **Buckets**: storage configuration summary
+
+> **Note:** Schema docs are also auto-generated inside the version folder (`vN/schema.md`) when running `migrations create` or `migrations update`.
+
+## Configuration (`appwrite/migration/config.json`)
+
+```json
+{
+  "collection": "migrations",
+  "database": "system"
+}
+```
+
+## CI/CD & Automated Deployment
+
+1. Install Appwrite CLI: `npm install -g appwrite-cli`
+2. Set environment variables: `APPWRITE_ENDPOINT`, `APPWRITE_PROJECT_ID`, `APPWRITE_API_KEY`
+3. The tool automatically configures the CLI via `appwrite client --key` — no login required.
+
+**Required API Key Scopes:**
+
+- `collections.read`, `collections.write`
+- `documents.read`, `documents.write`
+- `attributes.read`, `attributes.write`
+- `indexes.read`, `indexes.write`
+
+## CLI Commands
+
+| Command                       | Description                                                                          |
+| :---------------------------- | :----------------------------------------------------------------------------------- |
+| `init`                        | Initialize the project folder structure and config.                                  |
+| `migrations setup`            | Create the `system` database and `migrations` collection.                            |
+| `migrations create`           | Create a new migration version pulling the latest snapshot from Appwrite via CLI.    |
+| `migrations update <version>` | Update a version's snapshot by pulling from Appwrite via CLI.                        |
+| `migrations run`              | Execute all pending migrations in order.                                             |
+| `migrations status`           | List applied and pending migrations.                                                 |
+| `migrations docs`             | Pull current schema state from Appwrite and generate documentation with ER diagrams. |
+
+# AI Rules
+
+## Understanding the Data Models Layer
+
+📌 `schema.md` — The Source of Truth
+
+The most important file for understanding the application's **data model** is:
+
+```
+appwrite/schema.md
+```
+
+This is an **auto-generated** Markdown file that documents the **current state** of every database, collection, attribute, relationship, index, and storage bucket in the Appwrite project. It is generated from the latest `appwrite.config.json` snapshot via the `migrations docs` command.
+
+**When you need to understand the data model — always read `appwrite/schema.md` first.**
+
+It contains:
+
+- **ER Diagrams** (Mermaid) — visual representation of collection relationships per database.
+- **Collections** — complete list of every collection with:
+  - Column names, types, required flags, defaults, and constraints.
+  - Relationships: type (`oneToMany`, `manyToOne`, etc.), related collection, on-delete behavior, and two-way configuration.
+  - Indexes: type (unique, key, fulltext), columns, and sort orders.
+  - Permissions: read/write/create/delete access rules.
+- **Buckets** — storage buckets with max file size, extensions, compression, encryption, and antivirus settings.
+
+## Migration Commands
+
+This project uses `appwrite-ctl` to manage schema migrations. The available commands are:
+
+| Command                                    | Description                                                                           |
+| :----------------------------------------- | :------------------------------------------------------------------------------------ |
+| `appwrite-ctl migrations create`           | Create a new migration version pulling the latest snapshot from Appwrite via CLI.     |
+| `appwrite-ctl migrations update <version>` | Pull the current Appwrite state and update a version's snapshot.                      |
+| `appwrite-ctl migrations run`              | Execute all pending migrations in order (push schema → poll attributes → run script). |
+| `appwrite-ctl migrations status`           | List applied and pending migrations.                                                  |
+| `appwrite-ctl migrations docs`             | Pull current schema state from Appwrite and generate/regenerate `schema.md`.          |
+
+Each migration version lives in `appwrite/migration/vN/` and contains:
+
+- **`appwrite.config.json`** — the schema snapshot (Appwrite CLI format).
+- **`index.ts`** — the migration script with `up` (and optional `down`) functions.
+- **`schema.md`** — auto-generated docs for that version's snapshot.
+
+## How to Handle Data Model Changes
+
+When a change to the data model is needed (e.g. adding a collection, modifying attributes, creating indexes), follow these steps:
+
+1. **Create a new migration version:**
+
+   ```bash
+   npx appwrite-ctl migrations create
+   ```
+
+   This creates `appwrite/migration/vN/` and automatically pulls the current schema snapshot from Appwrite into `appwrite.config.json` via the CLI.
+
+2. **Edit the snapshot (`appwrite.config.json`)** inside the new version folder. Apply the desired schema changes directly to this JSON file — add/remove/modify collections, attributes, indexes, relationships, or buckets.
+
+3. **Write the migration script** in `appwrite/migration/vN/index.ts` if data manipulation is needed (e.g. seeding data, transforming existing documents). If the change is schema-only, the default empty `up` function is sufficient.
+
+4. **Regenerate the schema docs:**
+
+   ```bash
+   npx appwrite-ctl migrations docs
+   ```
+
+   This updates both `appwrite/migration/vN/schema.md` and the root `appwrite/schema.md`.
+
+5. **Verify** the updated `appwrite/schema.md` to confirm the changes are correct.
+
+> ⚠️ **Never edit `schema.md` files manually** — they are auto-generated. Always modify the `appwrite.config.json` snapshot and run `migrations docs` to regenerate.

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import chalk from 'chalk';
+import { runMigrations } from '../lib/runner.js';
+import { loadConfig } from '../lib/config.js';
+import { createAppwriteClient, ensureMigrationCollection, getAppliedMigrations, } from '../lib/appwrite.js';
+import { configureClient, pullSnapshot, getSnapshotFilename } from '../lib/cli.js';
+import { generateSchemaDoc } from '../lib/diagram.js';
+const program = new Command();
+const generateDocs = (snapshotPath, version, outputDir) => {
+    if (!fs.existsSync(snapshotPath))
+        return;
+    const markdown = generateSchemaDoc(snapshotPath, version);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    const outputPath = path.join(outputDir, 'schema.md');
+    fs.writeFileSync(outputPath, markdown);
+    console.log(chalk.green(`Schema docs updated at ${outputPath}`));
+};
+program
+    .name('appwrite-ctl')
+    .description('Appwrite CLI for managing migrations and other operations');
+program.option('-e, --env <path>', 'Path to environment file', '.env');
+program
+    .command('init')
+    .description('Initialize the project structure')
+    .action(async () => {
+    const rootDir = process.cwd();
+    const appwriteDir = path.join(rootDir, 'appwrite');
+    const migrationDir = path.join(appwriteDir, 'migration');
+    const configPath = path.join(migrationDir, 'config.json');
+    if (!fs.existsSync(appwriteDir))
+        fs.mkdirSync(appwriteDir);
+    if (!fs.existsSync(migrationDir))
+        fs.mkdirSync(migrationDir);
+    if (!fs.existsSync(configPath)) {
+        const config = {
+            collection: 'migrations',
+            database: 'system',
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log(chalk.green('Created appwrite/migration/config.json'));
+    }
+    else {
+        console.log(chalk.yellow('Config file already exists.'));
+    }
+    console.log(chalk.green('Initialization complete.'));
+});
+const migrations = program.command('migrations').description('Manage Appwrite migrations');
+migrations
+    .command('setup')
+    .description('Create the system database and migrations collection in Appwrite')
+    .action(async () => {
+    try {
+        const options = program.opts();
+        const config = loadConfig(options.env);
+        const { databases } = createAppwriteClient(config);
+        await ensureMigrationCollection(databases, config);
+        console.log(chalk.green(`System database '${config.database}' and collection '${config.migrationCollectionId}' ensured.`));
+    }
+    catch (error) {
+        console.error(chalk.red('Setup failed:'), error.message);
+        process.exit(1);
+    }
+});
+migrations
+    .command('create')
+    .description('Create a new migration version')
+    .action(async () => {
+    const migrationsDir = path.join(process.cwd(), 'appwrite', 'migration');
+    if (!fs.existsSync(migrationsDir)) {
+        fs.mkdirSync(migrationsDir, { recursive: true });
+    }
+    const snapshotFilename = getSnapshotFilename();
+    // Find next version number
+    const versionDirs = fs
+        .readdirSync(migrationsDir)
+        .filter((dir) => dir.startsWith('v') && fs.statSync(path.join(migrationsDir, dir)).isDirectory())
+        .map((d) => parseInt(d.substring(1)))
+        .sort((a, b) => a - b);
+    const nextVersion = (versionDirs.length > 0 ? versionDirs[versionDirs.length - 1] : 0) + 1;
+    const versionPath = path.join(migrationsDir, `v${nextVersion}`);
+    const name = `migration_v${nextVersion}`;
+    fs.mkdirSync(versionPath);
+    const indexContent = `import { Migration } from "appwrite-ctl";
+
+const migration: Migration = {
+  id: "${uuidv4()}",
+  description: "${name}",
+  requiresBackup: false,
+  up: async ({ client, databases, log, error }) => {
+    log("Executing up migration for ${name}");
+    // Write your migration logic here
+  },
+  down: async ({ client, databases, log, error }) => {
+    log("Executing down migration for ${name}");
+  }
+};
+
+export default migration;
+`;
+    fs.writeFileSync(path.join(versionPath, 'index.ts'), indexContent);
+    // Snapshot logic: always pull from Appwrite via CLI for a new migration.
+    console.log(chalk.blue('Pulling latest schema from Appwrite via CLI...'));
+    try {
+        const options = program.opts();
+        const config = loadConfig(options.env);
+        await configureClient(config);
+        await pullSnapshot(versionPath);
+        console.log(chalk.green('Successfully pulled snapshot from Appwrite.'));
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to pull snapshot: ${error.message}`));
+        console.warn(chalk.yellow('Creating empty snapshot placeholder.'));
+        const emptySnapshot = {
+            projectId: '',
+            projectName: '',
+            settings: {},
+            tablesDB: [],
+            tables: [],
+            buckets: [],
+            teams: [],
+            topics: [],
+        };
+        fs.writeFileSync(path.join(versionPath, snapshotFilename), JSON.stringify(emptySnapshot, null, 2));
+    }
+    console.log(chalk.green(`Created migration v${nextVersion} at ${versionPath}`));
+    generateDocs(path.join(versionPath, snapshotFilename), `v${nextVersion}`, versionPath);
+    generateDocs(path.join(versionPath, snapshotFilename), `v${nextVersion}`, path.join(process.cwd(), 'appwrite'));
+});
+migrations
+    .command('update <version>')
+    .description('Update snapshot for a version by pulling current state from Appwrite via CLI')
+    .action(async (version) => {
+    const migrationsDir = path.join(process.cwd(), 'appwrite', 'migration');
+    const versionPath = path.join(migrationsDir, version);
+    if (!fs.existsSync(versionPath)) {
+        console.error(chalk.red(`Version directory ${version} not found.`));
+        process.exit(1);
+    }
+    console.log(chalk.blue(`Updating snapshot for ${version} via CLI pull...`));
+    try {
+        const options = program.opts();
+        const config = loadConfig(options.env);
+        await configureClient(config);
+        await pullSnapshot(versionPath);
+        console.log(chalk.green(`Successfully updated snapshot for ${version}`));
+        const snapshotFilename = getSnapshotFilename();
+        generateDocs(path.join(versionPath, snapshotFilename), version, versionPath);
+        console.log(chalk.green(`Successfully updated schema.md for ${version}`));
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to update snapshot: ${error.message}`));
+        process.exit(1);
+    }
+});
+migrations
+    .command('run')
+    .description('Execute pending migrations')
+    .action(async () => {
+    try {
+        const options = program.opts();
+        await runMigrations(options.env);
+    }
+    catch (error) {
+        console.error(chalk.red('Migration run failed:'), error.message);
+        process.exit(1);
+    }
+});
+migrations
+    .command('status')
+    .description('List migration status')
+    .action(async () => {
+    try {
+        const options = program.opts();
+        const config = loadConfig(options.env);
+        const { databases } = createAppwriteClient(config);
+        const appliedIds = await getAppliedMigrations(databases, config);
+        const appliedSet = new Set(appliedIds);
+        const migrationsDir = path.join(process.cwd(), 'appwrite', 'migration');
+        if (!fs.existsSync(migrationsDir)) {
+            console.log('No migrations directory found.');
+            return;
+        }
+        const versionDirs = fs
+            .readdirSync(migrationsDir)
+            .filter((dir) => dir.startsWith('v') && fs.statSync(path.join(migrationsDir, dir)).isDirectory())
+            .sort((a, b) => parseInt(a.substring(1)) - parseInt(b.substring(1)));
+        console.log(chalk.bold.underline('\nMigration Status:\n'));
+        for (const version of versionDirs) {
+            const indexPath = path.join(migrationsDir, version, 'index.ts');
+            let id = 'unknown';
+            if (fs.existsSync(indexPath)) {
+                const content = fs.readFileSync(indexPath, 'utf8');
+                const match = content.match(/id:\s*["']([^"']+)["']/);
+                if (match)
+                    id = match[1];
+            }
+            const status = appliedSet.has(id) ? chalk.green('APPLIED') : chalk.yellow('PENDING');
+            console.log(`${version.padEnd(10)} [${id}] ${status}`);
+        }
+        console.log('');
+    }
+    catch (error) {
+        console.error(chalk.red('Status check failed:'), error.message);
+        process.exit(1);
+    }
+});
+migrations
+    .command('docs')
+    .description('Pull current state from Appwrite and generate schema documentation with ER diagrams')
+    .action(async () => {
+    try {
+        const options = program.opts();
+        const config = loadConfig(options.env);
+        console.log(chalk.blue(`Pulling latest schema from Appwrite to project root...`));
+        await configureClient(config);
+        const snapshotPath = await pullSnapshot();
+        console.log(chalk.blue('Generating documentation...'));
+        const appwriteDir = path.join(process.cwd(), 'appwrite');
+        generateDocs(snapshotPath, 'latest', appwriteDir);
+        // Cleanup the temporary snapshot pulled to root
+        if (fs.existsSync(snapshotPath)) {
+            fs.unlinkSync(snapshotPath);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Docs generation failed:'), error.message);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types/index.js';
+export * from './lib/appwrite.js';
+export * from './lib/config.js';
+export * from './lib/cli.js';
+export * from './lib/runner.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './types/index.js';
+export * from './lib/appwrite.js';
+export * from './lib/config.js';
+export * from './lib/cli.js';
+export * from './lib/runner.js';

package/dist/lib/appwrite.d.ts

@@ -0,0 +1,21 @@
+import { Client, Databases } from 'node-appwrite';
+import { AppConfig } from './config.js';
+/**
+ * Create Appwrite Client and Databases instance.
+ */
+export declare const createAppwriteClient: (config: AppConfig) => {
+    client: Client;
+    databases: Databases;
+};
+/**
+ * Ensure the system database and migrations collection exist.
+ */
+export declare const ensureMigrationCollection: (databases: Databases, config: AppConfig) => Promise<void>;
+/**
+ * Get list of applied migration IDs.
+ */
+export declare const getAppliedMigrations: (databases: Databases, config: AppConfig) => Promise<string[]>;
+/**
+ * Record a successfully applied migration.
+ */
+export declare const recordMigration: (databases: Databases, config: AppConfig, migrationId: string, name: string) => Promise<void>;

package/dist/lib/appwrite.js

@@ -0,0 +1,72 @@
+import { Client, Databases, Query } from 'node-appwrite';
+/**
+ * Create Appwrite Client and Databases instance.
+ */
+export const createAppwriteClient = (config) => {
+    const client = new Client()
+        .setEndpoint(config.endpoint)
+        .setProject(config.projectId)
+        .setKey(config.apiKey);
+    const databases = new Databases(client);
+    return { client, databases };
+};
+/**
+ * Ensure the system database and migrations collection exist.
+ */
+export const ensureMigrationCollection = async (databases, config) => {
+    // Ensure the system database exists.
+    try {
+        await databases.get(config.database);
+    }
+    catch (error) {
+        if (error.code === 404) {
+            console.log(`Creating system database '${config.database}'...`);
+            await databases.create(config.database, config.database);
+        }
+        else {
+            throw error;
+        }
+    }
+    // Ensure the migration collection exists within the system database.
+    try {
+        await databases.getCollection(config.database, config.migrationCollectionId);
+    }
+    catch (error) {
+        if (error.code === 404) {
+            console.log(`Creating migration collection '${config.migrationCollectionId}'...`);
+            await databases.createCollection(config.database, config.migrationCollectionId, config.migrationCollectionId);
+            await databases.createStringAttribute(config.database, config.migrationCollectionId, 'name', 255, true);
+            await databases.createDatetimeAttribute(config.database, config.migrationCollectionId, 'appliedAt', true);
+        }
+        else {
+            throw error;
+        }
+    }
+};
+/**
+ * Get list of applied migration IDs.
+ */
+export const getAppliedMigrations = async (databases, config) => {
+    try {
+        const response = await databases.listDocuments(config.database, config.migrationCollectionId, [
+            Query.limit(5000),
+        ]);
+        return response.documents.map((doc) => doc.$id);
+    }
+    catch (error) {
+        if (error.code === 404) {
+            // If DB or Collection unavailable, no migrations applied.
+            return [];
+        }
+        throw error;
+    }
+};
+/**
+ * Record a successfully applied migration.
+ */
+export const recordMigration = async (databases, config, migrationId, name) => {
+    await databases.createDocument(config.database, config.migrationCollectionId, migrationId, {
+        name,
+        appliedAt: new Date().toISOString(),
+    });
+};

package/dist/lib/cli.d.ts

@@ -0,0 +1,28 @@
+import { AppConfig } from './config.js';
+/**
+ * Configure the Appwrite CLI client for non-interactive use via API key.
+ */
+export declare const configureClient: (config: AppConfig) => Promise<void>;
+/**
+ * Pull a full snapshot from Appwrite into a target directory.
+ * Uses individual `appwrite pull <resource>` commands for non-interactive operation.
+ *
+ * The operation works in the project root (where appwrite.config.json lives).
+ * If a targetDir is provided, it copies the resulting file to the target directory and cleans up the root.
+ */
+export declare const pullSnapshot: (targetDir?: string) => Promise<string>;
+/**
+ * Push a snapshot from a version directory to the Appwrite project.
+ * Copies the version's appwrite.config.json to the project root,
+ * then runs individual `appwrite push <resource> --all --force` commands.
+ *
+ * The `projectId` in the snapshot is rewritten to match the current config,
+ * allowing the same snapshot to be pushed to any environment.
+ *
+ * `--all` auto-selects all resources, `--force` auto-confirms changes.
+ */
+export declare const pushSnapshot: (snapshotPath: string, config: AppConfig) => Promise<void>;
+/**
+ * Get the snapshot filename used for versioned snapshots.
+ */
+export declare const getSnapshotFilename: () => string;