vestrycms 0.0.0-stage → 0.2.0

package/dist/core/service.js

@@ -0,0 +1,478 @@
+import { applyAutoFields, toEditorValues, toStoredValues } from "./values.js";
+import { parseEntry, parseEntryList, serializeEntry, serializeEntryList, splitFrontmatter, } from "./entries.js";
+import { basename, collectionFormat, dirname, entryPath, extname, fillTemplate, isSafeRepoPath, isSafeSlug, joinPath, normalizePath, parsePathPattern, slugFromPath, slugify, } from "./paths.js";
+import { base64Decode, gitBlobSha, SourceError, toText, } from "./source.js";
+const IMAGE_EXTS = new Set([
+    "jpg",
+    "jpeg",
+    "png",
+    "gif",
+    "webp",
+    "avif",
+    "svg",
+]);
+export class ContentService {
+    config;
+    source;
+    index;
+    constructor(config, source, index) {
+        this.config = config;
+        this.source = source;
+        this.index = index;
+    }
+    collection(key) {
+        const c = this.config.collections?.[key];
+        if (!c)
+            throw new SourceError(`Unknown collection "${key}"`, 404, "not_found");
+        return c;
+    }
+    singleton(key) {
+        const s = this.config.singletons?.[key];
+        if (!s)
+            throw new SourceError(`Unknown singleton "${key}"`, 404, "not_found");
+        return s;
+    }
+    assetContainer(key) {
+        const a = this.config.assets?.[key];
+        if (!a)
+            throw new SourceError(`Unknown asset container "${key}"`, 404, "not_found");
+        return a;
+    }
+    // ---------------------------------------------------------------- entries
+    async listEntries(key) {
+        const col = this.collection(key);
+        const pattern = parsePathPattern(col.path);
+        const format = collectionFormat(col);
+        if (pattern.single) {
+            const file = await this.source.read(pattern.prefix);
+            if (!file)
+                return [];
+            const items = parseEntryList(format, toText(file.bytes));
+            const idField = col.idField ?? "id";
+            return items.map((data) => {
+                const slug = String(data[idField] ?? "");
+                return {
+                    slug,
+                    path: pattern.prefix,
+                    sha: file.sha,
+                    title: this.titleOf(col, data, slug),
+                    data: toEditorValues(col.schema, data, pattern.prefix),
+                    status: statusOf(col, data),
+                };
+            });
+        }
+        const files = (await this.source.list(pattern.directory)).filter((f) => slugFromPath(pattern, f.path) !== null);
+        const summaries = await Promise.all(files.map(async (f) => {
+            const { data, excerpt } = await this.frontmatterFor(f, format);
+            const slug = slugFromPath(pattern, f.path);
+            return {
+                slug,
+                path: f.path,
+                sha: f.sha,
+                title: this.titleOf(col, data, slug),
+                data: toEditorValues(col.schema, data, f.path),
+                status: statusOf(col, data),
+                excerpt,
+            };
+        }));
+        return sortEntries(col, summaries);
+    }
+    /**
+     * Frontmatter for a file: served from the build-time index when the blob
+     * SHA still matches, otherwise read from the source.
+     */
+    async frontmatterFor(file, format) {
+        const indexed = this.index.files[file.path];
+        if (indexed && indexed.sha === file.sha) {
+            return { data: indexed.data, excerpt: indexed.excerpt };
+        }
+        const data = await this.source.read(file.path);
+        if (!data)
+            return { data: {} };
+        const text = toText(data.bytes);
+        const parsed = parseEntry(format, text);
+        return { data: parsed.data, excerpt: makeExcerpt(parsed.body) };
+    }
+    async getEntry(key, slug) {
+        const col = this.collection(key);
+        const pattern = parsePathPattern(col.path);
+        const format = collectionFormat(col);
+        const head = await this.source.head();
+        if (pattern.single) {
+            const file = await this.source.read(pattern.prefix);
+            if (!file)
+                return null;
+            const items = parseEntryList(format, toText(file.bytes));
+            const idField = col.idField ?? "id";
+            const data = items.find((i) => String(i[idField]) === slug);
+            if (!data)
+                return null;
+            return {
+                slug,
+                path: pattern.prefix,
+                sha: file.sha,
+                title: this.titleOf(col, data, slug),
+                data: toEditorValues(col.schema, data, pattern.prefix),
+                status: statusOf(col, data),
+                body: "",
+                head,
+            };
+        }
+        if (!isSafeSlug(slug))
+            throw new SourceError("Invalid slug", 400, "bad_slug");
+        const path = entryPath(pattern, slug);
+        const file = await this.source.read(path);
+        if (!file)
+            return null;
+        const parsed = parseEntry(format, toText(file.bytes));
+        return {
+            slug,
+            path,
+            sha: file.sha,
+            title: this.titleOf(col, parsed.data, slug),
+            data: toEditorValues(col.schema, parsed.data, path),
+            status: statusOf(col, parsed.data),
+            body: parsed.body,
+            head,
+        };
+    }
+    async saveEntry(key, slug, input) {
+        const col = this.collection(key);
+        const pattern = parsePathPattern(col.path);
+        const format = collectionFormat(col);
+        const isNew = slug === null;
+        let data = applyAutoFields(col.schema, { ...input.data });
+        if (pattern.single) {
+            const idField = col.idField ?? "id";
+            const file = await this.source.read(pattern.prefix);
+            const items = file ? parseEntryList(format, toText(file.bytes)) : [];
+            if (file && input.sha && input.sha !== file.sha) {
+                throw new SourceError("This file changed since you opened it.", 409, "conflict");
+            }
+            const id = String(data[idField] ?? slug ?? this.newSlug(col, data));
+            if (!id)
+                throw new SourceError(`Entries need an "${idField}"`, 400, "validation");
+            data[idField] = id;
+            const stored = toStoredValues(col.schema, data, pattern.prefix);
+            const existingIdx = items.findIndex((i) => String(i[idField]) === (slug ?? id));
+            if (isNew && existingIdx !== -1) {
+                throw new SourceError(`An entry with id "${id}" already exists`, 409, "exists");
+            }
+            if (existingIdx === -1)
+                items.push(stored);
+            else
+                items[existingIdx] = stored;
+            const text = serializeEntryList(format, items);
+            const changes = [
+                { path: pattern.prefix, content: text },
+                ...uploadChanges(input.uploads),
+            ];
+            const commit = await this.source.commit(changes, {
+                message: this.commitMessage(col, isNew ? "Create" : "Update", id, this.titleOf(col, data, id), key, input.message),
+            });
+            return {
+                slug: id,
+                sha: await gitBlobSha(text),
+                commit: commit.sha,
+                path: pattern.prefix,
+            };
+        }
+        const finalSlug = slug ?? (input.slug?.trim() || this.newSlug(col, data));
+        if (!isSafeSlug(finalSlug))
+            throw new SourceError(`Invalid slug "${finalSlug}"`, 400, "bad_slug");
+        const path = entryPath(pattern, finalSlug);
+        const existing = await this.source.read(path);
+        if (isNew && existing) {
+            throw new SourceError(`An entry at "${path}" already exists`, 409, "exists");
+        }
+        if (!isNew && existing && input.sha && input.sha !== existing.sha) {
+            throw new SourceError("This entry changed since you opened it.", 409, "conflict");
+        }
+        const stored = toStoredValues(col.schema, data, path);
+        const text = input.raw ??
+            serializeEntry(format, { data: stored, body: input.body ?? "" });
+        const changes = [
+            { path, content: text },
+            ...uploadChanges(input.uploads),
+        ];
+        const commit = await this.source.commit(changes, {
+            message: this.commitMessage(col, isNew ? "Create" : "Update", finalSlug, this.titleOf(col, data, finalSlug), key, input.message),
+        });
+        return {
+            slug: finalSlug,
+            sha: await gitBlobSha(text),
+            commit: commit.sha,
+            path,
+        };
+    }
+    async deleteEntry(key, slug) {
+        const col = this.collection(key);
+        if (col.delete === false)
+            throw new SourceError("Deleting is disabled for this collection", 403, "forbidden");
+        const pattern = parsePathPattern(col.path);
+        const format = collectionFormat(col);
+        if (pattern.single) {
+            const idField = col.idField ?? "id";
+            const file = await this.source.read(pattern.prefix);
+            const items = file ? parseEntryList(format, toText(file.bytes)) : [];
+            const next = items.filter((i) => String(i[idField]) !== slug);
+            if (next.length === items.length)
+                throw new SourceError("Entry not found", 404, "not_found");
+            const commit = await this.source.commit([{ path: pattern.prefix, content: serializeEntryList(format, next) }], { message: this.commitMessage(col, "Delete", slug, slug, key) });
+            return { commit: commit.sha };
+        }
+        if (!isSafeSlug(slug))
+            throw new SourceError("Invalid slug", 400, "bad_slug");
+        const path = entryPath(pattern, slug);
+        const commit = await this.source.commit([{ path, delete: true }], {
+            message: this.commitMessage(col, "Delete", slug, slug, key),
+        });
+        return { commit: commit.sha };
+    }
+    // -------------------------------------------------------------- singletons
+    async getSingleton(key) {
+        const s = this.singleton(key);
+        const format = collectionFormat(s);
+        const path = normalizePath(s.path);
+        const head = await this.source.head();
+        const file = await this.source.read(path);
+        const parsed = file
+            ? parseEntry(format, toText(file.bytes))
+            : { data: {}, body: "" };
+        return {
+            slug: key,
+            path,
+            sha: file?.sha ?? "",
+            title: s.label,
+            data: toEditorValues(s.schema, parsed.data, path),
+            status: null,
+            body: parsed.body,
+            head,
+        };
+    }
+    async saveSingleton(key, input) {
+        const s = this.singleton(key);
+        const format = collectionFormat(s);
+        const path = normalizePath(s.path);
+        const existing = await this.source.read(path);
+        if (existing && input.sha && input.sha !== existing.sha) {
+            throw new SourceError("This file changed since you opened it.", 409, "conflict");
+        }
+        const data = applyAutoFields(s.schema, { ...input.data });
+        const stored = toStoredValues(s.schema, data, path);
+        const text = input.raw ??
+            serializeEntry(format, { data: stored, body: input.body ?? "" });
+        const commit = await this.source.commit([{ path, content: text }, ...uploadChanges(input.uploads)], {
+            message: input.message ??
+                fillTemplate(s.commitMessage ?? this.config.commitMessage ?? "Update {title}", {
+                    action: "Update",
+                    title: s.label,
+                    slug: key,
+                    collection: key,
+                }),
+        });
+        return { sha: await gitBlobSha(text), commit: commit.sha };
+    }
+    // ------------------------------------------------------------------ assets
+    async listAssets(containerKey, subdir = "") {
+        const container = this.assetContainer(containerKey);
+        const dir = joinPath(container.directory, subdir);
+        if (!isSafeRepoPath(dir) ||
+            !dir.startsWith(normalizePath(container.directory))) {
+            throw new SourceError("Invalid directory", 400, "bad_path");
+        }
+        const files = await this.source.list(dir);
+        const items = [];
+        const folders = new Set();
+        const prefix = `${dir}/`;
+        for (const f of files) {
+            const rest = f.path.slice(prefix.length);
+            const slash = rest.indexOf("/");
+            if (slash !== -1) {
+                folders.add(rest.slice(0, slash));
+                continue;
+            }
+            if (rest.startsWith("."))
+                continue;
+            const ext = extname(rest);
+            items.push({
+                name: rest,
+                path: f.path,
+                sha: f.sha,
+                size: f.size,
+                ext,
+                kind: IMAGE_EXTS.has(ext) ? "image" : "file",
+            });
+        }
+        items.sort((a, b) => a.name.localeCompare(b.name));
+        return { items, folders: [...folders].sort() };
+    }
+    async uploadAssets(containerKey, subdir, files) {
+        const container = this.assetContainer(containerKey);
+        const dir = joinPath(container.directory, subdir);
+        const changes = [];
+        const paths = [];
+        for (const f of files) {
+            const name = safeFileName(f.name);
+            const ext = extname(name);
+            const accept = container.accept;
+            if (accept && !accept.includes(ext)) {
+                throw new SourceError(`"${name}" is not an accepted file type`, 400, "validation");
+            }
+            const path = joinPath(dir, name);
+            if (!isSafeRepoPath(path))
+                throw new SourceError("Invalid file name", 400, "bad_path");
+            changes.push({ path, content: base64Decode(f.base64) });
+            paths.push(path);
+        }
+        const commit = await this.source.commit(changes, {
+            message: files.length === 1
+                ? `Upload ${basename(paths[0])} to ${dir}`
+                : `Upload ${files.length} files to ${dir}`,
+        });
+        return { commit: commit.sha, paths };
+    }
+    async deleteAsset(containerKey, path) {
+        const container = this.assetContainer(containerKey);
+        const n = normalizePath(path);
+        if (!n.startsWith(`${normalizePath(container.directory)}/`) ||
+            !isSafeRepoPath(n)) {
+            throw new SourceError("Path is outside the asset container", 400, "bad_path");
+        }
+        const commit = await this.source.commit([{ path: n, delete: true }], {
+            message: `Delete ${basename(n)}`,
+        });
+        return { commit: commit.sha };
+    }
+    /** Raw file read restricted to configured asset containers and entry directories. */
+    async readFile(path) {
+        const n = normalizePath(path);
+        if (!isSafeRepoPath(n))
+            throw new SourceError("Invalid path", 400, "bad_path");
+        const allowed = this.allowedDirectories().some((d) => n.startsWith(`${d}/`));
+        if (!allowed)
+            throw new SourceError("Path is not readable through Vestry", 403, "forbidden");
+        return this.source.read(n);
+    }
+    allowedDirectories() {
+        const dirs = new Set();
+        if (this.config.logo && !/^https?:\/\//.test(this.config.logo)) {
+            dirs.add(dirname(normalizePath(this.config.logo)));
+        }
+        for (const a of Object.values(this.config.assets ?? {}))
+            dirs.add(normalizePath(a.directory));
+        const addSchemaDirs = (schema) => {
+            for (const f of Object.values(schema)) {
+                if (f.type === "image" || f.type === "file")
+                    dirs.add(normalizePath(f.directory));
+                if (f.type === "object")
+                    addSchemaDirs(f.fields);
+                if (f.type === "array")
+                    addSchemaDirs({ item: f.of });
+            }
+        };
+        for (const c of Object.values(this.config.collections ?? {}))
+            addSchemaDirs(c.schema);
+        for (const s of Object.values(this.config.singletons ?? {}))
+            addSchemaDirs(s.schema);
+        for (const c of Object.values(this.config.components ?? {}))
+            addSchemaDirs(c.props ?? {});
+        return [...dirs];
+    }
+    // ----------------------------------------------------------------- helpers
+    titleOf(col, data, slug) {
+        const v = data[col.titleField ?? "title"];
+        return typeof v === "string" && v.trim() ? v : slug;
+    }
+    newSlug(col, data) {
+        const template = col.slug?.template;
+        if (template)
+            return fillTemplate(template, data, { slug: true });
+        const from = col.slug?.from ?? col.titleField ?? "title";
+        const v = data[from];
+        const s = v instanceof Date ? v.toISOString().slice(0, 10) : String(v ?? "");
+        const slug = slugify(s);
+        if (!slug)
+            throw new SourceError(`Cannot derive a slug from "${from}"`, 400, "validation");
+        return slug;
+    }
+    commitMessage(col, action, slug, title, collection, override) {
+        if (override?.trim())
+            return override.trim();
+        const template = col.commitMessage ??
+            this.config.commitMessage ??
+            "{action} {singular}: {title}";
+        return fillTemplate(template, {
+            action,
+            slug,
+            title,
+            collection,
+            label: col.label,
+            singular: col.singular ?? col.label,
+        });
+    }
+}
+function statusOf(col, data) {
+    if (!col.status)
+        return null;
+    const publishedWhen = col.status.publishedWhen ?? true;
+    const field = col.schema[col.status.field];
+    const fallback = field?.type === "boolean" ? (field.default ?? false) : false;
+    const v = data[col.status.field];
+    const bool = typeof v === "boolean"
+        ? v
+        : v === undefined || v === null
+            ? fallback
+            : Boolean(v);
+    return bool === publishedWhen ? "published" : "draft";
+}
+function sortEntries(col, entries) {
+    const sort = col.sort;
+    const dir = sort?.direction === "asc" ? 1 : -1;
+    const field = sort?.field;
+    return [...entries].sort((a, b) => {
+        const av = field ? sortable(a.data[field]) : a.slug;
+        const bv = field ? sortable(b.data[field]) : b.slug;
+        if (av === bv)
+            return a.slug < b.slug ? -dir : dir;
+        return av < bv ? -dir : dir;
+    });
+}
+function sortable(v) {
+    if (v instanceof Date)
+        return v.getTime();
+    if (typeof v === "number")
+        return v;
+    if (typeof v === "boolean")
+        return v ? 1 : 0;
+    return String(v ?? "");
+}
+function makeExcerpt(body) {
+    const text = body
+        .replace(/^import .*$/gm, "")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/[#*_>`[\]]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    return text ? text.slice(0, 200) : undefined;
+}
+function uploadChanges(uploads) {
+    return (uploads ?? []).map((u) => {
+        if (!isSafeRepoPath(u.path))
+            throw new SourceError(`Invalid upload path "${u.path}"`, 400, "bad_path");
+        return { path: normalizePath(u.path), content: base64Decode(u.base64) };
+    });
+}
+export function safeFileName(name) {
+    const base = basename(name.replace(/\\/g, "/"));
+    const ext = extname(base);
+    const stem = base.slice(0, ext ? base.length - ext.length - 1 : undefined);
+    const cleanStem = stem
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/[^A-Za-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase();
+    return ext ? `${cleanStem || "file"}.${ext}` : cleanStem || "file";
+}
+export { splitFrontmatter };

package/dist/core/source.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The content source abstraction. Vestry reads and writes files through one
+ * of these; the control panel never touches storage directly.
+ *
+ * Two implementations ship today:
+ *  - `LocalSource` – the project directory on disk (used by `astro dev`).
+ *  - `GitHubSource` – the GitHub REST (Git Data) API.
+ *
+ * Other git hosts (GitLab, Gitea, a bare git remote) would implement the same
+ * interface.
+ */
+export interface TreeEntry {
+    /** Repository-relative path, posix separators. */
+    path: string;
+    /** Git blob SHA (or a content hash for sources without git). */
+    sha: string;
+    size?: number;
+}
+export interface FileData {
+    bytes: Uint8Array;
+    sha: string;
+}
+export type FileChange = {
+    path: string;
+    content: string | Uint8Array;
+    encoding?: "utf-8" | "binary";
+} | {
+    path: string;
+    delete: true;
+};
+export interface CommitInfo {
+    /** The resulting commit (or head) identifier. */
+    sha: string;
+    /** Link to the commit, if the source has one. */
+    url?: string;
+}
+export interface CommitOptions {
+    message: string;
+    /** Who made the change; sources that commit as a service account credit them (e.g. as a co-author). */
+    author?: {
+        name: string;
+        email: string;
+    };
+    /** Required for optimistic concurrency: the head the client last saw. */
+    expectedHead?: string;
+}
+export interface SourceInfo {
+    kind: "local" | "github";
+    /** Human description, e.g. `iBelieve/mluther.org@master` or the local directory. */
+    label: string;
+    branch?: string;
+    /** Link to browse the source, if any. */
+    url?: string;
+}
+export interface ContentSource {
+    info(): SourceInfo;
+    /** Current head commit SHA. Local sources return a synthetic value. */
+    head(): Promise<string>;
+    /** All files under `directory` (recursive). */
+    list(directory: string): Promise<TreeEntry[]>;
+    /** Read a file, or null if it doesn't exist. */
+    read(path: string): Promise<FileData | null>;
+    /** Apply a set of changes as one commit. */
+    commit(changes: FileChange[], options: CommitOptions): Promise<CommitInfo>;
+}
+export declare class SourceError extends Error {
+    status: number;
+    code: string;
+    constructor(message: string, status?: number, code?: string);
+}
+export declare function toBytes(content: string | Uint8Array): Uint8Array;
+export declare function toText(bytes: Uint8Array): string;
+/** Git blob SHA-1 of the given content: `sha1("blob <len>\0" + bytes)`. */
+export declare function gitBlobSha(content: string | Uint8Array): Promise<string>;
+export declare function hex(bytes: Uint8Array): string;
+export declare function base64Encode(bytes: Uint8Array): string;
+export declare function base64Decode(b64: string): Uint8Array;
+/** Wraps a source so every commit carries `author` unless the caller set one. */
+export declare function withAuthor(source: ContentSource, author: {
+    name: string;
+    email: string;
+}): ContentSource;

package/dist/core/source.js

@@ -0,0 +1,75 @@
+/**
+ * The content source abstraction. Vestry reads and writes files through one
+ * of these; the control panel never touches storage directly.
+ *
+ * Two implementations ship today:
+ *  - `LocalSource` – the project directory on disk (used by `astro dev`).
+ *  - `GitHubSource` – the GitHub REST (Git Data) API.
+ *
+ * Other git hosts (GitLab, Gitea, a bare git remote) would implement the same
+ * interface.
+ */
+export class SourceError extends Error {
+    status;
+    code;
+    constructor(message, status = 500, code = "source_error") {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "SourceError";
+    }
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+export function toBytes(content) {
+    return typeof content === "string" ? encoder.encode(content) : content;
+}
+export function toText(bytes) {
+    return decoder.decode(bytes);
+}
+/** Git blob SHA-1 of the given content: `sha1("blob <len>\0" + bytes)`. */
+export async function gitBlobSha(content) {
+    const bytes = toBytes(content);
+    const header = encoder.encode(`blob ${bytes.byteLength}\0`);
+    const buf = new Uint8Array(header.byteLength + bytes.byteLength);
+    buf.set(header, 0);
+    buf.set(bytes, header.byteLength);
+    const digest = await crypto.subtle.digest("SHA-1", buf);
+    return hex(new Uint8Array(digest));
+}
+export function hex(bytes) {
+    let s = "";
+    for (const b of bytes)
+        s += b.toString(16).padStart(2, "0");
+    return s;
+}
+export function base64Encode(bytes) {
+    if (typeof Buffer !== "undefined")
+        return Buffer.from(bytes).toString("base64");
+    let bin = "";
+    const chunk = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunk) {
+        bin += String.fromCharCode(...bytes.subarray(i, i + chunk));
+    }
+    return btoa(bin);
+}
+export function base64Decode(b64) {
+    const clean = b64.replace(/\s+/g, "");
+    if (typeof Buffer !== "undefined")
+        return new Uint8Array(Buffer.from(clean, "base64"));
+    const bin = atob(clean);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        out[i] = bin.charCodeAt(i);
+    return out;
+}
+/** Wraps a source so every commit carries `author` unless the caller set one. */
+export function withAuthor(source, author) {
+    return {
+        info: () => source.info(),
+        head: () => source.head(),
+        list: (directory) => source.list(directory),
+        read: (path) => source.read(path),
+        commit: (changes, options) => source.commit(changes, { author, ...options }),
+    };
+}

package/dist/core/sources/github-app.d.ts

@@ -0,0 +1,26 @@
+export interface GitHubAppCredentials {
+    appId: string;
+    installationId: string;
+    /** PEM private key (PKCS#1 as GitHub issues it, or PKCS#8), `\n`-escaped or base64-encoded PEM also accepted. */
+    privateKey: string;
+    apiBase?: string;
+}
+export type TokenProvider = (() => Promise<string>) & {
+    /** Forget the cached token, e.g. after GitHub rejected it. */
+    invalidate(): void;
+};
+interface CachedToken {
+    token: string;
+    expiresAt: number;
+}
+/**
+ * Returns a provider that mints (and caches) installation tokens for the
+ * app. Concurrent callers share one in-flight mint; a failed mint is
+ * forgotten so the next caller retries; tokens are renewed a minute early.
+ */
+export declare function installationTokenProvider(creds: GitHubAppCredentials): TokenProvider;
+export declare function mintInstallationToken(creds: GitHubAppCredentials): Promise<CachedToken>;
+/** A GitHub App JWT: issued a minute ago (clock skew), valid for nine more. */
+export declare function signAppJwt(appId: string, privateKey: string): Promise<string>;
+export declare function importRsaPrivateKey(pem: string): Promise<CryptoKey>;
+export {};