@revoengine/cli 1.0.9 → 1.0.11

package/dist/src/project.d.ts

@@ -1,4 +1,6 @@
 import type { ParsedArgs } from './types.ts';
+import { type ComponentIdentityConfig, type ComponentIdentityMode } from './resource-metadata.ts';
+import { type TrackedResource } from './tracked-resources.ts';
 export declare const REVO_PROJECT_DIR = ".revoengine";
 export declare const REVO_TYPES_DIR: string;
 export declare const REVO_TYPES_FILE: string;
@@ -15,6 +17,9 @@ export type ProjectInvocation = {
     action: 'init' | 'update';
     targetArg?: string;
     extraArgs: string[];
+    identityMode?: ComponentIdentityMode;
+    stableKeyName?: string;
+    trackedResources?: TrackedResource[];
 };
 export type EditorTypesBundle = {
     code: string;
@@ -34,6 +39,10 @@ export type RevoProjectMetadata = {
     hash: string;
     lastSyncAt: string;
     workspace?: string;
+    componentIdentity?: ComponentIdentityConfig;
+    /** Legacy project metadata field. Read for migration, but no longer written. */
+    stableKeyName?: string;
+    trackedResources?: TrackedResource[];
 };
 export type ProjectSyncInput = {
     endpoint: string;
@@ -43,6 +52,9 @@ export type ProjectSyncInput = {
     libVersion: string;
     hash: string;
     lastSyncAt: string;
+    authProfile?: string;
+    componentIdentity?: ComponentIdentityConfig;
+    trackedResources?: TrackedResource[];
 };
 export type ProjectConfigResult = {
     filePath: string;
@@ -69,6 +81,7 @@ export declare function buildProjectMetadata(input: {
     baseUrl: string;
     bundle: EditorTypesBundle;
     now?: Date;
+    authProfile?: string;
 }): {
     schemaVersion: 1;
     endpoint: string;
@@ -80,21 +93,16 @@ export declare function buildProjectMetadata(input: {
 };
 export declare function findProjectMetadataFile(startDir?: string): string;
 export declare function readProjectMetadata(startDir?: string): RevoProjectMetadata | null;
+export declare function readProjectStableKeyName(startDir?: string): string;
+export declare function readProjectComponentIdentity(startDir?: string): ComponentIdentityConfig;
+export declare function readProjectTrackedResources(startDir?: string): TrackedResource[];
 export declare function resolveProjectRoot(startDir?: string): string;
 export declare function resolveProjectWorkspace(startDir?: string): string;
 export declare function buildProjectSyncState(input: {
     fallbackEndpoint: string;
     bundle: EditorTypesBundle;
     now?: Date;
-}): {
-    endpoint: string;
-    code: string;
-    definitions: unknown[];
-    apiVersion: string;
-    libVersion: string;
-    hash: string;
-    lastSyncAt: string;
-};
+}): ProjectSyncInput;
 export declare function syncProjectFiles(layoutOrTargetDir: ProjectTargetLayout | string, input: ProjectSyncInput): {
     projectDir: string;
     typesFile: string;

package/dist/src/project.js

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { readJsonFile } from "./utils.js";
+import { COMPONENT_IDENTITY_BY_ID, DEFAULT_COMPONENT_IDENTITY, DEFAULT_STABLE_KEY_NAME, normalizeComponentIdentityConfig, normalizeComponentIdentityMode, normalizeStableKeyName, } from "./resource-metadata.js";
+import { TRACK_ALL_RESOURCES, normalizeTrackedResources, } from "./tracked-resources.js";
 export const REVO_PROJECT_DIR = '.revoengine';
 export const REVO_TYPES_DIR = path.join(REVO_PROJECT_DIR, 'types');
 export const REVO_TYPES_FILE = path.join(REVO_TYPES_DIR, 'revo.editor.d.ts');
@@ -180,6 +182,22 @@ function appendUnique(list, value) {
     }
     return list;
 }
+function readResourceSelectionArgs(args) {
+    const values = [];
+    for (const name of ['resources', 'resource', 'tracked-resources', 'trackedResources']) {
+        const value = args[name];
+        if (typeof value === 'string') {
+            values.push(value);
+        }
+        else if (Array.isArray(value)) {
+            values.push(...value);
+        }
+        else if (value === true) {
+            throw new Error(`--${name} requires a value such as "all" or "component".`);
+        }
+    }
+    return values.length > 0 ? values : undefined;
+}
 function writeJsonFile(filePath, value) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
@@ -187,27 +205,37 @@ function writeJsonFile(filePath, value) {
 export function resolveProjectInvocation(args) {
     const projectArgs = args._.slice(1);
     const [first, second, ...rest] = projectArgs;
+    const explicitStableKeyName = readString(args.stableKeyName)
+        || readString(args['stable-key-name']);
+    const stableKeyName = explicitStableKeyName
+        ? normalizeStableKeyName(explicitStableKeyName)
+        : undefined;
+    const explicitIdentityMode = readString(args.identityMode)
+        || readString(args['identity-mode']);
+    const identityMode = explicitIdentityMode
+        ? normalizeComponentIdentityMode(explicitIdentityMode)
+        : stableKeyName
+            ? 'stableKey'
+            : undefined;
+    const trackedResourceArgs = readResourceSelectionArgs(args);
+    const trackedResources = trackedResourceArgs ? normalizeTrackedResources(trackedResourceArgs) : undefined;
     if (!first) {
-        return {
-            action: 'init',
-            extraArgs: [],
-        };
+        throw new Error('Missing project action. Use `revo project init [path]` or `revo project update [path]`.');
     }
     if (first === 'init' || first === 'update') {
         return {
             action: first,
             targetArg: second,
             extraArgs: rest,
+            identityMode,
+            stableKeyName,
+            ...(trackedResources ? { trackedResources } : {}),
         };
     }
     if (first === 'switch') {
         throw new Error('`revo project switch` was removed because credentials are no longer instance-scoped.');
     }
-    return {
-        action: 'init',
-        targetArg: first,
-        extraArgs: second ? [second, ...rest] : rest,
-    };
+    throw new Error(`Unknown project action "${first}". Use \`revo project init [path]\` or \`revo project update [path]\`.`);
 }
 function normalizeWorkspaceDirectory(projectRoot, workspaceRoot) {
     const relative = path.relative(projectRoot, workspaceRoot).split(path.sep).join('/');
@@ -320,7 +348,7 @@ export function buildProjectMetadata(input) {
     return {
         schemaVersion: 1,
         endpoint: bundle.endpoint || buildEditorEndpoint(baseUrl),
-        authProfile: 'default',
+        authProfile: input.authProfile || 'default',
         apiVersion: getRequiredMetadataValue(bundle, 'apiVersion'),
         libVersion: getRequiredMetadataValue(bundle, 'libVersion'),
         hash: getRequiredMetadataValue(bundle, 'hash'),
@@ -363,6 +391,40 @@ export function readProjectMetadata(startDir = process.cwd()) {
     }
     return raw;
 }
+export function readProjectStableKeyName(startDir = process.cwd()) {
+    const metadata = readProjectMetadata(startDir);
+    const identity = readProjectComponentIdentity(startDir);
+    return normalizeStableKeyName(identity.mode === 'stableKey'
+        ? identity.metadataProperty
+        : metadata?.stableKeyName || DEFAULT_STABLE_KEY_NAME);
+}
+export function readProjectComponentIdentity(startDir = process.cwd()) {
+    const metadata = readProjectMetadata(startDir);
+    if (!metadata) {
+        return COMPONENT_IDENTITY_BY_ID;
+    }
+    if (metadata.componentIdentity && isRecord(metadata.componentIdentity)) {
+        const mode = readString(metadata.componentIdentity.mode);
+        const metadataProperty = readString(metadata.componentIdentity.metadataProperty);
+        if (mode) {
+            return normalizeComponentIdentityConfig({
+                mode: normalizeComponentIdentityMode(mode),
+                ...(metadataProperty ? { metadataProperty } : {}),
+            });
+        }
+    }
+    if (metadata.stableKeyName) {
+        return normalizeComponentIdentityConfig({
+            mode: 'stableKey',
+            metadataProperty: metadata.stableKeyName,
+        }, DEFAULT_COMPONENT_IDENTITY);
+    }
+    return COMPONENT_IDENTITY_BY_ID;
+}
+export function readProjectTrackedResources(startDir = process.cwd()) {
+    const metadata = readProjectMetadata(startDir);
+    return normalizeTrackedResources(metadata?.trackedResources || TRACK_ALL_RESOURCES);
+}
 export function resolveProjectRoot(startDir = process.cwd()) {
     const metadataFile = findProjectMetadataFile(startDir);
     return metadataFile ? path.dirname(path.dirname(metadataFile)) : '';
@@ -435,11 +497,13 @@ export function syncProjectFiles(layoutOrTargetDir, input) {
     writeJsonFile(metadataFile, {
         schemaVersion: 1,
         endpoint: input.endpoint,
-        authProfile: 'default',
+        authProfile: input.authProfile || 'default',
         apiVersion: input.apiVersion,
         libVersion: input.libVersion,
         hash: input.hash,
         lastSyncAt: input.lastSyncAt,
+        componentIdentity: normalizeComponentIdentityConfig(input.componentIdentity, DEFAULT_COMPONENT_IDENTITY),
+        trackedResources: normalizeTrackedResources(input.trackedResources || TRACK_ALL_RESOURCES),
         ...(workspaceDirectory !== '.' ? { workspace: workspaceDirectory } : {}),
     });
     const configResult = ensureProjectConfig(workspaceRoot, toPosixRelative(workspaceRoot, typesFile));
@@ -480,6 +544,9 @@ export function ensureProjectConfig(rootDir, typesInclude = REVO_TYPES_FILE) {
     if (!fs.existsSync(tsconfigPath) && !fs.existsSync(jsconfigPath)) {
         writeJsonFile(tsconfigPath, {
             compilerOptions: {
+                target: 'ES2022',
+                module: 'ESNext',
+                moduleDetection: 'force',
                 allowJs: true,
                 checkJs: false,
                 noEmit: true,
@@ -499,6 +566,15 @@ export function ensureProjectConfig(rootDir, typesInclude = REVO_TYPES_FILE) {
     const filePath = fs.existsSync(tsconfigPath) ? tsconfigPath : jsconfigPath;
     const parsed = parseConfigFile(filePath);
     const compilerOptions = ensureObjectField(parsed, 'compilerOptions', filePath);
+    if (compilerOptions.target === undefined) {
+        compilerOptions.target = 'ES2022';
+    }
+    if (compilerOptions.module === undefined) {
+        compilerOptions.module = 'ESNext';
+    }
+    if (compilerOptions.moduleDetection === undefined) {
+        compilerOptions.moduleDetection = 'force';
+    }
     if (compilerOptions.allowJs === undefined) {
         compilerOptions.allowJs = true;
     }

package/dist/src/prompt.js

@@ -1,4 +1,5 @@
 import readline from 'node:readline/promises';
+import { Writable } from 'node:stream';
 export function isInteractiveTerminal() {
     return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
@@ -23,32 +24,23 @@ export async function promptSecret(message) {
     if (!isInteractiveTerminal()) {
         return '';
     }
+    const mutedOutput = new Writable({
+        write(_chunk, _encoding, callback) {
+            callback();
+        },
+    });
     const rl = readline.createInterface({
         input: process.stdin,
-        output: process.stdout,
+        output: mutedOutput,
         terminal: true,
     });
-    let muted = true;
-    const originalWriteToOutput = rl._writeToOutput.bind(rl);
-    rl._writeToOutput = (value) => {
-        if (!muted) {
-            originalWriteToOutput(value);
-            return;
-        }
-        if (value.startsWith(`${message}: `)) {
-            originalWriteToOutput(value);
-            return;
-        }
-        // Preserve terminal editing/paste behavior while masking visible content.
-        originalWriteToOutput('*');
-    };
     try {
-        const answer = await rl.question(`${message}: `);
-        return answer;
+        process.stdout.write(`${message}: `);
+        return await rl.question('');
     }
     finally {
-        muted = false;
         rl.close();
+        process.stdout.write('\n');
     }
 }
 export async function promptConfirm(message, defaultValue = false) {

package/dist/src/resource-metadata.d.ts

@@ -0,0 +1,25 @@
+import type { ComponentRecord } from './types.ts';
+export declare const DEFAULT_STABLE_KEY_NAME = "stableKey";
+export declare const NULL_CATEGORY_KEY = "__no_category__";
+export type ComponentIdentityMode = 'componentId' | 'stableKey';
+export type ComponentIdentityConfig = {
+    mode: ComponentIdentityMode;
+    metadataProperty?: string;
+};
+export declare const COMPONENT_IDENTITY_BY_ID: ComponentIdentityConfig;
+export declare const DEFAULT_COMPONENT_IDENTITY: ComponentIdentityConfig;
+export declare function normalizeStableKeyValue(value: string): string;
+export declare function normalizeStableKeyName(value: string | null | undefined): string;
+export declare function normalizeComponentIdentityMode(value: string | null | undefined): ComponentIdentityMode;
+export declare function normalizeComponentIdentityConfig(value: Partial<ComponentIdentityConfig> | null | undefined, fallback?: ComponentIdentityConfig): ComponentIdentityConfig;
+export declare function sameComponentIdentityConfig(left: ComponentIdentityConfig, right: ComponentIdentityConfig): boolean;
+export declare function readConfiguredResourceMetadataStableKey(component: ComponentRecord, stableKeyName?: string): string | null;
+export declare function readComponentIdentityValue(component: ComponentRecord, identity: ComponentIdentityConfig): string | null;
+export declare function readResourceMetadataStableKey(component: ComponentRecord, stableKeyName?: string): string | null;
+export declare function buildStableKey(component: ComponentRecord, stableKeyName?: string): string;
+export declare function buildStableKeyValue(component: ComponentRecord, stableKeyName?: string): string;
+export declare function buildResourceIdentityStableKeyValue(component: ComponentRecord): string;
+export declare function buildResourceMetadataWithStableKey(component: ComponentRecord, stableKeyName?: string): {
+    [x: string]: unknown;
+};
+export declare function sanitizeUserMetadata(value: unknown): Record<string, unknown>;

package/dist/src/resource-metadata.js

@@ -0,0 +1,132 @@
+export const DEFAULT_STABLE_KEY_NAME = 'stableKey';
+export const NULL_CATEGORY_KEY = '__no_category__';
+export const COMPONENT_IDENTITY_BY_ID = {
+    mode: 'componentId',
+};
+export const DEFAULT_COMPONENT_IDENTITY = {
+    mode: 'stableKey',
+    metadataProperty: DEFAULT_STABLE_KEY_NAME,
+};
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function normalizeKeyPart(value) {
+    return (value ?? '').trim().replace(/\s+/g, ' ').toLowerCase();
+}
+export function normalizeStableKeyValue(value) {
+    return normalizeKeyPart(value);
+}
+export function normalizeStableKeyName(value) {
+    const normalized = (value || DEFAULT_STABLE_KEY_NAME).trim();
+    if (!normalized) {
+        return DEFAULT_STABLE_KEY_NAME;
+    }
+    if (!/^[A-Za-z_$][A-Za-z0-9_$-]*$/.test(normalized)) {
+        throw new Error('Stable key metadata name must start with a letter, "_", or "$" and contain only letters, digits, "_", "$", or "-".');
+    }
+    return normalized;
+}
+export function normalizeComponentIdentityMode(value) {
+    const normalized = (value || '').trim().toLowerCase().replace(/[-_\s]/g, '');
+    if (normalized === 'stablekey' || normalized === 'metadata') {
+        return 'stableKey';
+    }
+    if (normalized === 'componentid' || normalized === 'id' || normalized === 'uuid') {
+        return 'componentId';
+    }
+    throw new Error('Component identity mode must be "stableKey" or "componentId".');
+}
+export function normalizeComponentIdentityConfig(value, fallback = COMPONENT_IDENTITY_BY_ID) {
+    const mode = value?.mode
+        ? normalizeComponentIdentityMode(value.mode)
+        : fallback.mode;
+    if (mode === 'componentId') {
+        return { mode };
+    }
+    return {
+        mode,
+        metadataProperty: normalizeStableKeyName(value?.metadataProperty || fallback.metadataProperty),
+    };
+}
+export function sameComponentIdentityConfig(left, right) {
+    const normalizedLeft = normalizeComponentIdentityConfig(left);
+    const normalizedRight = normalizeComponentIdentityConfig(right);
+    return normalizedLeft.mode === normalizedRight.mode
+        && normalizedLeft.metadataProperty === normalizedRight.metadataProperty;
+}
+function readConfiguredStableKeyFromRecord(value, stableKeyName) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    return readString(value[stableKeyName])
+        ?? (isRecord(value.details) ? readString(value.details[stableKeyName]) : null);
+}
+function readAnyStableKeyFromRecord(value, stableKeyName) {
+    return readConfiguredStableKeyFromRecord(value, stableKeyName)
+        ?? (stableKeyName === DEFAULT_STABLE_KEY_NAME ? null : readConfiguredStableKeyFromRecord(value, DEFAULT_STABLE_KEY_NAME));
+}
+export function readConfiguredResourceMetadataStableKey(component, stableKeyName = DEFAULT_STABLE_KEY_NAME) {
+    const fieldName = normalizeStableKeyName(stableKeyName);
+    return readConfiguredStableKeyFromRecord(component.metadata, fieldName)
+        ?? readConfiguredStableKeyFromRecord(component.metaData, fieldName)
+        ?? readConfiguredStableKeyFromRecord(component.resourceMetadata, fieldName);
+}
+export function readComponentIdentityValue(component, identity) {
+    const normalized = normalizeComponentIdentityConfig(identity);
+    if (normalized.mode === 'componentId') {
+        return readString(component.componentId) ?? readString(component.id);
+    }
+    return readConfiguredResourceMetadataStableKey(component, normalized.metadataProperty);
+}
+export function readResourceMetadataStableKey(component, stableKeyName = DEFAULT_STABLE_KEY_NAME) {
+    const fieldName = normalizeStableKeyName(stableKeyName);
+    return readAnyStableKeyFromRecord(component.metadata, fieldName)
+        ?? readAnyStableKeyFromRecord(component.metaData, fieldName)
+        ?? readAnyStableKeyFromRecord(component.resourceMetadata, fieldName);
+}
+export function buildStableKey(component, stableKeyName = DEFAULT_STABLE_KEY_NAME) {
+    const metadataStableKey = readResourceMetadataStableKey(component, stableKeyName);
+    if (metadataStableKey) {
+        return normalizeKeyPart(metadataStableKey);
+    }
+    const category = normalizeKeyPart(component.category) || NULL_CATEGORY_KEY;
+    const name = normalizeKeyPart(component.name);
+    return `${category}/${name}`;
+}
+export function buildStableKeyValue(component, stableKeyName = DEFAULT_STABLE_KEY_NAME) {
+    const metadataStableKey = readResourceMetadataStableKey(component, stableKeyName);
+    if (metadataStableKey) {
+        return metadataStableKey;
+    }
+    return buildResourceIdentityStableKeyValue(component);
+}
+export function buildResourceIdentityStableKeyValue(component) {
+    const category = typeof component.category === 'string' && component.category.trim()
+        ? component.category.trim()
+        : NULL_CATEGORY_KEY;
+    const name = typeof component.name === 'string' ? component.name.trim() : '';
+    return `${category}/${name}`;
+}
+export function buildResourceMetadataWithStableKey(component, stableKeyName = DEFAULT_STABLE_KEY_NAME) {
+    const fieldName = normalizeStableKeyName(stableKeyName);
+    return {
+        ...sanitizeUserMetadata(component.metadata),
+        [fieldName]: buildStableKeyValue(component, fieldName),
+    };
+}
+export function sanitizeUserMetadata(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    const sanitized = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (key.startsWith('__')) {
+            continue;
+        }
+        sanitized[key] = entry;
+    }
+    return sanitized;
+}

package/dist/src/resource-syncs/database-schema-sync.d.ts

@@ -0,0 +1,117 @@
+import type { DatabaseSchemaStatsRecord, RevoClient } from '../client.ts';
+export declare const DATABASE_SCHEMAS_DIRECTORY = "DatabaseSchemas";
+export declare const DATABASE_SCHEMA_MANIFEST_FILE = "database-schema.json";
+type PortableDefinition = Record<string, unknown>;
+export type DatabaseSchemaManifest = {
+    kind: 'database-schema' | 'database-partition';
+    stableKey: string;
+    name: string;
+    category?: string | null;
+    description?: string;
+    metadata: Record<string, unknown>;
+    type?: string;
+    definition?: PortableDefinition[];
+    partition?: Record<string, unknown>;
+    parentStableKey?: string;
+    migration?: {
+        foreignReferences: 'manual';
+    };
+};
+export type DatabaseSchemaPullResult = {
+    pulled: Array<{
+        manifest: DatabaseSchemaManifest;
+        targetPath: string;
+    }>;
+    pruned: Array<{
+        stableKey: string;
+        targetPath: string;
+    }>;
+    skipped: Array<{
+        targetPath: string;
+        reason: string;
+    }>;
+    diagnostics: Array<{
+        stableKey: string;
+        audit?: unknown;
+        acl?: unknown;
+        tags?: unknown;
+    }>;
+};
+export type DatabaseSchemaPlanStatus = 'clean' | 'create' | 'safe-update' | 'remote-changed' | 'conflict' | 'missing-lock' | 'orphan-root' | 'orphan-partition' | 'delete-partition' | 'previously-deleted-partition' | 'replacement-requires-two-phases' | 'unmanaged' | 'collision' | 'reconciled' | 'manual-schema-migration-required' | 'access-policy-required';
+export type DatabaseSchemaChange = {
+    kind: 'field-changed' | 'immutable-field' | 'column-added' | 'column-removed' | 'column-changed' | 'column-renamed' | 'column-stable-key-missing' | 'database-view-dependency' | 'column-order' | 'foreign-reference' | 'audit-trigger-rebuild';
+    field: string;
+    risk: 'safe' | 'manual' | 'operational';
+    before?: unknown;
+    after?: unknown;
+    column?: string;
+    hint: string;
+};
+export type DatabaseSchemaPlanItem = {
+    status: DatabaseSchemaPlanStatus;
+    stableKey?: string;
+    name: string;
+    kind?: DatabaseSchemaManifest['kind'];
+    parentStableKey?: string;
+    reason?: string;
+    changedFields?: string[];
+    changes?: DatabaseSchemaChange[];
+    hints: string[];
+    desiredHash?: string;
+    currentHash?: string;
+    baselineHash?: string;
+    stats?: DatabaseSchemaStatsRecord['size'];
+};
+export type DatabaseSchemasPlan = {
+    resourceType: 'database-schema';
+    env: string;
+    withStats: boolean;
+    skipPartitions: boolean;
+    counts: Record<DatabaseSchemaPlanStatus, number>;
+    blockers: string[];
+    warnings: string[];
+    exclusions: string[];
+    items: DatabaseSchemaPlanItem[];
+};
+export type DatabaseSchemaPushResult = {
+    stableKey: string;
+    action: 'create' | 'update' | 'reconcile' | 'delete' | 'skipped';
+    status: 'deployed' | 'skipped' | 'failed' | 'write-unverified';
+    targetPath: string;
+    reason?: string;
+    error?: string;
+};
+export declare function hashPortableDatabaseSchema(manifest: DatabaseSchemaManifest): string;
+export declare function buildDatabaseSchemasPlan(input: {
+    client: RevoClient;
+    cwd: string;
+    envName: string;
+    stableKeyName: string;
+    withStats?: boolean;
+    skipPartitions?: boolean;
+}): Promise<DatabaseSchemasPlan>;
+export declare function pullDatabaseSchemasToWorkspace(input: {
+    client: RevoClient;
+    cwd: string;
+    envName: string;
+    stableKeyName: string;
+    force?: boolean;
+    strict?: boolean;
+    pruneOrphans?: boolean;
+}): Promise<DatabaseSchemaPullResult>;
+export declare function pushDatabaseSchemas(input: {
+    client: RevoClient;
+    cwd: string;
+    envName: string;
+    stableKeyName: string;
+    stableKey?: string;
+    force?: boolean;
+    prunePartitions?: boolean;
+    prunePartitionsConfirmed?: boolean;
+    pruneOrphans?: boolean;
+    pruneOrphansConfirmed?: boolean;
+}): Promise<{
+    plan: DatabaseSchemasPlan;
+    results: DatabaseSchemaPushResult[];
+}>;
+export {};