@google-cloud/kcmd 0.0.0-stage → 0.1.0

package/build/ts/kcmd/gcp/spanner.d.ts

@@ -0,0 +1,63 @@
+import * as api from './api';
+import * as context from './context';
+export interface Operation {
+    name?: string;
+    done?: boolean;
+    error?: {
+        code?: number;
+        message?: string;
+        [key: string]: any;
+    };
+    response?: {
+        [key: string]: any;
+    };
+    metadata?: {
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface Session {
+    name?: string;
+    [key: string]: any;
+}
+export interface ResultSet {
+    stats?: {
+        queryPlan?: {
+            planNodes?: Array<{
+                [key: string]: any;
+            }>;
+        };
+    };
+    [key: string]: any;
+}
+export interface SpannerType {
+    code: string;
+}
+export interface Instance {
+    name?: string;
+    config?: string;
+    [key: string]: any;
+}
+export interface InstanceConfig {
+    name?: string;
+    replicas?: Array<{
+        location?: string;
+        type?: string;
+        defaultLeaderLocation?: boolean;
+    }>;
+    [key: string]: any;
+}
+export declare class SpannerClient extends api.ApiClient {
+    constructor(ctx: context.ApiContext);
+    updateDatabaseDdl(project: string, instance: string, database: string, statements: string[]): Promise<api.ApiResult<Operation>>;
+    getDatabase(project: string, instance: string, database: string): Promise<api.ApiResult<{
+        name?: string;
+        [key: string]: any;
+    }>>;
+    getInstance(project: string, instance: string): Promise<api.ApiResult<Instance>>;
+    getInstanceConfig(configName: string): Promise<api.ApiResult<InstanceConfig>>;
+    getOperation(operationName: string): Promise<api.ApiResult<Operation>>;
+    createSession(project: string, instance: string, database: string): Promise<api.ApiResult<Session>>;
+    deleteSession(sessionName: string): Promise<api.ApiResult<{}>>;
+    planDml(sessionName: string, sql: string, params?: Record<string, null>, paramTypes?: Record<string, SpannerType>): Promise<api.ApiResult<ResultSet>>;
+}

package/build/ts/kcmd/gcp/spanner.js

@@ -0,0 +1,123 @@
+"use strict";
+// API client for Cloud Spanner, covering three surfaces kcmd needs: Database
+// Admin (updateDatabaseDdl, getDatabase and getOperation) to check the
+// database and deploy Spanner Graph DDL; the data plane (sessions and
+// executeSql) to PLAN an action's DML against the live database before
+// publishing it; and Instance Admin (getInstance and getInstanceConfig) to
+// find the region where Knowledge Catalog keeps a table's entry.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpannerClient = void 0;
+const api = __importStar(require("./api"));
+class SpannerClient extends api.ApiClient {
+    constructor(ctx) {
+        super('https://spanner.googleapis.com', 'v1', ctx);
+    }
+    // Applies DDL statements to a database. This is asynchronous: the response is
+    // a long-running Operation whose `name` the caller polls with getOperation
+    // until `done`. Statements are applied in order. The REST binding for
+    // updateDatabaseDdl is PATCH on the `.../ddl` collection (a POST 404s --
+    // verified live), so this uses PATCH, not the more common POST-to-create.
+    async updateDatabaseDdl(project, instance, database, statements) {
+        const name = `projects/${project}/instances/${instance}/databases/${database}/ddl`;
+        return await this._patch(name, { statements });
+    }
+    // Fetches a database's metadata.
+    async getDatabase(project, instance, database) {
+        return await this._get(`projects/${project}/instances/${instance}/databases/${database}`);
+    }
+    // Fetches an instance's metadata, which names its instance config.
+    async getInstance(project, instance) {
+        return await this._get(`projects/${project}/instances/${instance}`);
+    }
+    // Fetches an instance config by its full name, as Instance.config gives it.
+    async getInstanceConfig(configName) {
+        return await this._get(configName);
+    }
+    // Fetches a long-running operation by its resource name (as returned in
+    // Operation.name, e.g.
+    // `projects/.../instances/.../databases/.../operations/...`).
+    async getOperation(operationName) {
+        return await this._get(operationName);
+    }
+    // Opens a data-plane session on a database. Every executeSql call runs in
+    // one; the caller is responsible for deleting it when done.
+    async createSession(project, instance, database) {
+        const parent = `projects/${project}/instances/${instance}/databases/${database}/sessions`;
+        return await this._post(parent, {});
+    }
+    // Closes a session by its full resource name. Deleting a session discards
+    // any transaction still open on it, which is how a PLAN-only caller disposes
+    // of the read-write transactions it began and never committed.
+    async deleteSession(sessionName) {
+        return await this._delete(sessionName);
+    }
+    // Plans a DML statement WITHOUT executing it, and without writing anything.
+    //
+    // Two parts of the request are load-bearing and were both established live
+    // against a real database:
+    //
+    //   - `queryMode: PLAN` asks Spanner to parse, resolve every table and
+    //     column, and type-check the statement, then return the query plan
+    //     instead of running it. A `Table not found`, an `Unrecognized name`
+    //     (with Spanner's own "Did you mean ...?"), a bad assignment type and a
+    //     wrong-dialect construct all come back here as an error.
+    //   - `transaction.begin.readWrite` is NOT optional. Spanner refuses DML
+    //     outside a read-write transaction even in PLAN mode
+    //     ("DML statements can only be performed in a read-write transaction"),
+    //     so the request begins one. Because PLAN executes nothing, the
+    //     transaction is never committed and the caller drops it by deleting the
+    //     session.
+    //
+    // `params`/`paramTypes` are optional: Spanner infers a `@name` reference's
+    // type from its context when neither is supplied. Passing them turns the
+    // action's DECLARED parameter types into a claim checked against the real
+    // column types, which is the reason to bother. A parameter named in `params`
+    // must also appear in `paramTypes` -- a null with no declared type is the one
+    // combination Spanner cannot infer.
+    async planDml(sessionName, sql, params, paramTypes) {
+        const body = {
+            sql,
+            queryMode: 'PLAN',
+            transaction: { begin: { readWrite: {} } },
+        };
+        if (params && Object.keys(params).length) {
+            body.params = params;
+            body.paramTypes = paramTypes;
+        }
+        return await this._post(`${sessionName}:executeSql`, body);
+    }
+}
+exports.SpannerClient = SpannerClient;

package/build/ts/kcmd/index.d.ts

@@ -0,0 +1,7 @@
+export * from './layout';
+export * from './manifest';
+export * from './metadata';
+export * from './snapshot';
+export * from './sync';
+export * as gcp from './gcp/context';
+export * as dataplex from './gcp/dataplex';

package/build/ts/kcmd/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataplex = exports.gcp = void 0;
+__exportStar(require("./layout"), exports);
+__exportStar(require("./manifest"), exports);
+__exportStar(require("./metadata"), exports);
+__exportStar(require("./snapshot"), exports);
+__exportStar(require("./sync"), exports);
+exports.gcp = __importStar(require("./gcp/context"));
+exports.dataplex = __importStar(require("./gcp/dataplex"));

package/build/ts/kcmd/layout.d.ts

@@ -0,0 +1,16 @@
+import * as md from './metadata';
+export declare enum Layouts {
+    STANDARD = "standard",
+    DOCUMENTS = "documents",
+    SEMANTIC_MODEL = "semantic-model",
+    OKF = "okf"
+}
+export interface CatalogLayout {
+    init(): Promise<void>;
+    entryExists(name: string): boolean;
+    listEntries(): string[];
+    loadEntry(name: string): Promise<md.Entry>;
+    saveEntry(name: string, entry: md.Entry): Promise<void>;
+    deleteEntry(name: string): Promise<void>;
+}
+export declare function createLayout(layout: Layouts, catalogPath: string, entryGroup?: string): CatalogLayout;

package/build/ts/kcmd/layout.js

@@ -0,0 +1,31 @@
+"use strict";
+// Defines the Catalog metadata layout abstraction.
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Layouts = void 0;
+exports.createLayout = createLayout;
+const standard_1 = require("./layouts/standard");
+const documents_1 = require("./layouts/documents");
+const semantic_model_1 = require("./layouts/semantic-model");
+const okf_1 = require("./layouts/okf");
+var Layouts;
+(function (Layouts) {
+    Layouts["STANDARD"] = "standard";
+    Layouts["DOCUMENTS"] = "documents";
+    Layouts["SEMANTIC_MODEL"] = "semantic-model";
+    Layouts["OKF"] = "okf";
+})(Layouts || (exports.Layouts = Layouts = {}));
+function createLayout(layout, catalogPath, entryGroup) {
+    switch (layout) {
+        case Layouts.STANDARD:
+            return new standard_1.StandardLayout(catalogPath);
+        case Layouts.DOCUMENTS:
+            return new documents_1.DocumentsLayout(catalogPath);
+        case Layouts.SEMANTIC_MODEL:
+            return new semantic_model_1.SemanticModelLayout(catalogPath, entryGroup);
+        case Layouts.OKF:
+            return new okf_1.OkfLayout(catalogPath, entryGroup);
+        default:
+            throw new Error(`Unknown layout type: ${layout}`);
+    }
+}

package/build/ts/kcmd/layouts/documents.d.ts

@@ -0,0 +1,24 @@
+import * as md from '../metadata';
+import { CatalogLayout } from '../layout';
+export declare class DocumentsLayout implements CatalogLayout {
+    private _catalogPath;
+    private readonly _index;
+    constructor(catalogPath: string);
+    init(): Promise<void>;
+    entryExists(name: string): boolean;
+    listEntries(): string[];
+    loadEntry(name: string): Promise<md.Entry>;
+    saveEntry(name: string, entry: md.Entry): Promise<void>;
+    deleteEntry(name: string): Promise<void>;
+    private _synthesizeIndexEntries;
+}
+export declare function splitFrontmatter(content: string): {
+    metadata?: any;
+    body: string;
+};
+export declare function joinFrontmatter(metadata: object, body: string): string;
+export declare function parseMarkdown(content: string): {
+    entry: md.Entry | null;
+    body: string;
+};
+export declare function toMarkdown(entry: md.Entry, body: string): string;

package/build/ts/kcmd/layouts/documents.js

@@ -0,0 +1,264 @@
+"use strict";
+// Implements the documents layout (markdown files in directory)
+//
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentsLayout = void 0;
+exports.splitFrontmatter = splitFrontmatter;
+exports.joinFrontmatter = joinFrontmatter;
+exports.parseMarkdown = parseMarkdown;
+exports.toMarkdown = toMarkdown;
+const fs = __importStar(require("node:fs"));
+const glob = __importStar(require("glob"));
+const path = __importStar(require("node:path"));
+const yaml = __importStar(require("yaml"));
+const md = __importStar(require("../metadata"));
+const DEFAULT_ENTRY_TYPE = 'dataplex-types.global.generic';
+const INDEX_NAME = 'index';
+class DocumentsLayout {
+    _catalogPath = '';
+    // Maps entry name -> local file path, or null for synthetic directory-index
+    // entries that don't have a backing file on disk.
+    _index = new Map();
+    constructor(catalogPath) {
+        this._catalogPath = catalogPath;
+    }
+    async init() {
+        this._index.clear();
+        if (!fs.existsSync(this._catalogPath)) {
+            return;
+        }
+        const matches = await glob.glob('**/*.md', {
+            cwd: this._catalogPath,
+            absolute: true,
+            nodir: true,
+        });
+        for (const localPath of matches) {
+            const name = deriveEntryNameFromPath(localPath, this._catalogPath);
+            this._index.set(name, localPath);
+        }
+        this._synthesizeIndexEntries();
+    }
+    entryExists(name) {
+        return this._index.has(name);
+    }
+    listEntries() {
+        return Array.from(this._index.keys());
+    }
+    async loadEntry(name) {
+        if (!this._index.has(name)) {
+            throw new Error(`Entry not found: ${name}`);
+        }
+        const entryPath = this._index.get(name) ?? null;
+        let parsed = null;
+        let body = '';
+        if (entryPath) {
+            const content = await fs.promises.readFile(entryPath, 'utf8');
+            const result = parseMarkdown(content);
+            parsed = result.entry;
+            body = result.body;
+        }
+        const entry = parsed ?? { type: DEFAULT_ENTRY_TYPE, resource: {} };
+        entry.name = name;
+        entry.resource = entry.resource ?? {};
+        const parentName = deriveParentLocalName(name);
+        if (parentName !== undefined) {
+            entry.resource.parent = parentName;
+        }
+        else {
+            delete entry.resource.parent;
+        }
+        // Ensure the entry's type aspect is present — Dataplex create requires it.
+        entry.aspects = entry.aspects ?? {};
+        entry.aspects[entry.type] = entry.aspects[entry.type] ?? {};
+        const bodyTrimmed = body.trim();
+        if (bodyTrimmed) {
+            if (!entry.aspects[md.OVERVIEW_ASPECT]) {
+                entry.aspects[md.OVERVIEW_ASPECT] = {};
+            }
+            entry.aspects[md.OVERVIEW_ASPECT].content = bodyTrimmed;
+            entry.aspects[md.OVERVIEW_ASPECT].contentType ??= 'MARKDOWN';
+        }
+        return entry;
+    }
+    async saveEntry(name, entry) {
+        const entryPath = path.join(this._catalogPath, `${name}.md`);
+        await fs.promises.mkdir(path.dirname(entryPath), { recursive: true });
+        // Clone to avoid mutating original entry aspects
+        const clonedEntry = JSON.parse(JSON.stringify(entry));
+        let body = '';
+        if (clonedEntry.aspects?.[md.OVERVIEW_ASPECT]) {
+            const aspect = clonedEntry.aspects[md.OVERVIEW_ASPECT];
+            if (aspect.content !== undefined) {
+                body = aspect.content;
+                delete aspect.content;
+                // Any other content type stays in the front matter, so a push
+                // keeps it.
+                if (aspect.contentType === 'MARKDOWN')
+                    delete aspect.contentType;
+            }
+        }
+        const fileContent = toMarkdown(clonedEntry, body);
+        await fs.promises.writeFile(entryPath, fileContent, 'utf8');
+        this._index.set(name, entryPath);
+        this._synthesizeIndexEntries();
+    }
+    async deleteEntry(name) {
+        const entryPath = this._index.get(name);
+        if (!entryPath) {
+            throw new Error(`Entry not found: ${name}`);
+        }
+        if (!fs.existsSync(entryPath)) {
+            throw new Error(`Entry not found: ${name}`);
+        }
+        await fs.promises.unlink(entryPath);
+        this._index.delete(name);
+        this._synthesizeIndexEntries();
+    }
+    // Ensure every directory that contains entries has an index entry. Directories
+    // whose own index file is absent get a synthetic entry (no backing file).
+    // Synthetic entries left behind by a previous synthesis pass are dropped if
+    // their directory no longer has any other entries.
+    _synthesizeIndexEntries() {
+        for (const [name, entryPath] of this._index) {
+            if (entryPath === null) {
+                this._index.delete(name);
+            }
+        }
+        const dirs = new Set();
+        for (const name of this._index.keys()) {
+            const segments = name.split('/');
+            for (let i = 0; i < segments.length; i++) {
+                dirs.add(segments.slice(0, i).join('/'));
+            }
+        }
+        for (const dir of dirs) {
+            const indexName = dir ? `${dir}/${INDEX_NAME}` : INDEX_NAME;
+            if (!this._index.has(indexName)) {
+                this._index.set(indexName, null);
+            }
+        }
+    }
+}
+exports.DocumentsLayout = DocumentsLayout;
+function deriveEntryNameFromPath(absolutePath, catalogPath) {
+    const rel = path.relative(catalogPath, absolutePath);
+    return rel.replace(/\.md$/, '');
+}
+function deriveParentLocalName(name) {
+    const segments = name.split('/');
+    const leaf = segments[segments.length - 1];
+    // The root index entry has no parent.
+    if (leaf === INDEX_NAME && segments.length === 1) {
+        return undefined;
+    }
+    const parentDir = leaf === INDEX_NAME
+        ? segments.slice(0, -2)
+        : segments.slice(0, -1);
+    return [...parentDir, INDEX_NAME].join('/');
+}
+// Splits markdown text into its YAML frontmatter, parsed, and its body.
+// `metadata` is undefined when the text does not open with a `---` block.
+function splitFrontmatter(content) {
+    const lines = content.split(/\r?\n/);
+    const endIndex = lines[0] === '---' ? lines.indexOf('---', 1) : -1;
+    if (endIndex === -1)
+        return { body: content };
+    return {
+        metadata: yaml.parse(lines.slice(1, endIndex).join('\n')),
+        body: lines.slice(endIndex + 1).join('\n'),
+    };
+}
+// Markdown text with `metadata` as its YAML frontmatter and `body` after it.
+function joinFrontmatter(metadata, body) {
+    return `---\n${yaml.stringify(metadata).trim()}\n---\n${body}`;
+}
+function parseMarkdown(content) {
+    const { metadata, body } = splitFrontmatter(content);
+    if (metadata === undefined) {
+        return { entry: null, body };
+    }
+    const entry = (metadata.catalogEntry ?? {});
+    entry.type = (typeof metadata.type === 'string' && metadata.type.split('.').length === 3)
+        ? metadata.type
+        : DEFAULT_ENTRY_TYPE;
+    entry.resource = entry.resource ?? {};
+    entry.resource.displayName = metadata.title;
+    entry.resource.description = metadata.description;
+    if (metadata.tags) {
+        entry.resource.labels = entry.resource.labels ?? {};
+        for (const tag of metadata.tags) {
+            entry.resource.labels[tag] = 'true';
+        }
+    }
+    if (metadata.timeStamp) {
+        entry.resource.updateTime = metadata.timeStamp;
+        if (!entry.resource.createTime) {
+            entry.resource.createTime = metadata.timeStamp;
+        }
+    }
+    return { entry, body };
+}
+function toMarkdown(entry, body) {
+    // Clone to be able to make modifications
+    const entryClone = JSON.parse(JSON.stringify(entry));
+    const tags = [];
+    if (entry.resource.labels) {
+        for (const [k, v] of Object.entries(entryClone.resource.labels ?? {})) {
+            if (v == 'true') {
+                tags.push(k);
+            }
+        }
+    }
+    const metadata = {
+        type: entry.type,
+        title: entry.resource.displayName ?? entry.resource.name,
+        description: entry.resource.description ?? undefined,
+        tags: tags.length ? tags : undefined,
+        timeStamp: entry.resource.updateTime ?? entry.resource.createTime ?? undefined,
+        catalogEntry: entryClone
+    };
+    delete entryClone.name;
+    delete entryClone.resource.displayName;
+    delete entryClone.resource.description;
+    delete entryClone.resource.updateTime;
+    delete entryClone.resource.createTime;
+    delete entryClone.resource.parent;
+    delete entryClone.type;
+    for (const tag of tags) {
+        delete entryClone.resource.labels[tag];
+    }
+    return joinFrontmatter(metadata, body);
+}

package/build/ts/kcmd/layouts/okf.d.ts

@@ -0,0 +1,31 @@
+import * as dataplex from '../gcp/dataplex';
+import { CatalogLayout } from '../layout';
+import * as md from '../metadata';
+import { Concept } from '../okf/concept';
+import { BundleLinksResult } from '../okf/links';
+export declare const BUNDLE_DIR = "bundle";
+export declare class OkfLayout implements CatalogLayout {
+    private readonly _bundlePath;
+    private readonly _container;
+    private readonly _index;
+    constructor(bundlePath: string, entryGroupContainer?: string);
+    get bundlePath(): string;
+    bundleExists(): boolean;
+    /** Resolves `<bundle>/<id>.md`, rejecting any ID that escapes `bundle/`. */
+    resolveConceptPath(id: string): string;
+    /** Display path relative to workspace root (e.g. `bundle/tables/trips.md`). */
+    relativeBundlePath(name: string): string;
+    init(): Promise<void>;
+    entryExists(name: string): boolean;
+    listEntries(): string[];
+    loadEntry(name: string): Promise<md.Entry>;
+    /** Validates and builds the `Concept` `saveEntry` would write, without I/O. */
+    previewConcept(name: string, entry: md.Entry): Concept;
+    saveEntry(name: string, entry: md.Entry): Promise<void>;
+    deleteEntry(name: string): Promise<void>;
+    /** Reads `bundle/_links.yaml` plus any frontmatter `links` on indexed concepts. */
+    readLinks(): BundleLinksResult;
+    /** Writes or removes `bundle/_links.yaml` to match pulled EntryLinks. */
+    writeLinks(links: dataplex.EntryLink[]): Promise<void>;
+    private _pruneEmptyDirs;
+}