cvdl-ts 1.0.18 → 1.0.19

package/dist/Alignment.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default_ = void 0;
+exports.default_ = default_;
 function default_() {
     return "Left";
 }
-exports.default_ = default_;

package/dist/AnyLayout.d.ts

@@ -3,19 +3,19 @@ import { LayoutSchema } from "./LayoutSchema";
 import { Storage } from "./Storage";
 import { Resume } from "./Resume";
 import { ResumeLayout } from "./ResumeLayout";
-import * as fontkit from 'fontkit';
+import * as fontkit from "fontkit";
 import { Layout } from ".";
 export type ElementPath = {
-    tag: 'none';
+    tag: "none";
 } | {
-    tag: 'section';
+    tag: "section";
     section: string;
 } | {
-    tag: 'item';
+    tag: "item";
     section: string;
     item: number;
 } | {
-    tag: 'field';
+    tag: "field";
     section: string;
     item: number;
     field: string;
@@ -34,4 +34,4 @@ export declare class FontDict {
     load_fonts_from_schema(schema: LayoutSchema, storage: Storage): Promise<void>;
     get_font(name: string): fontkit.Font;
 }
-export declare function render({ resume, layout_schemas, data_schemas, resume_layout, storage, fontDict }: RenderProps): Promise<Layout.RenderedLayout[]>;
+export declare function render({ resume, layout_schemas, data_schemas, resume_layout, storage, fontDict, }: RenderProps): Promise<Layout.RenderedLayout[]>;

package/dist/AnyLayout.js

@@ -23,7 +23,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.render = exports.FontDict = void 0;
+exports.FontDict = void 0;
+exports.render = render;
 const ResumeLayout_1 = require("./ResumeLayout");
 const fontkit = __importStar(require("fontkit"));
 const _1 = require(".");
@@ -32,16 +33,21 @@ class FontDict {
         this.fonts = new Map();
     }
     async load_fonts_from_schema(schema, storage) {
-        for (const font of schema.fonts()) {
+        for (const font of [...schema.fonts()]) {
             const fontName = _1.Font.full_name(font);
-            console.log(`Loading font ${fontName}`);
+            console.error(`Loading font ${fontName}`);
             if (this.fonts.has(fontName)) {
-                console.log(`Font ${fontName} is already loaded`);
+                console.error(`Font ${fontName} is already loaded`);
                 continue;
             }
-            const font_data = await storage.load_font(font);
-            const fontkit_font = fontkit.create(font_data);
-            this.fonts.set(fontName, fontkit_font);
+            try {
+                const font_data = await storage.load_font(font);
+                const fontkit_font = fontkit.create(font_data);
+                this.fonts.set(fontName, fontkit_font);
+            }
+            catch (e) {
+                console.error(`Error loading font ${fontName}: ${e}`);
+            }
         }
     }
     get_font(name) {
@@ -53,21 +59,20 @@ class FontDict {
     }
 }
 exports.FontDict = FontDict;
-async function render({ resume, layout_schemas, data_schemas, resume_layout, storage, fontDict }) {
+async function render({ resume, layout_schemas, data_schemas, resume_layout, storage, fontDict, }) {
     // Compute the total usable width by subtracting the margins from the document width
-    const width = resume_layout.width - (resume_layout.margin.left + resume_layout.margin.right);
+    const width = resume_layout.width -
+        (resume_layout.margin.left + resume_layout.margin.right);
     // If the resume is double column, then the usable width is halved
     const column_width = resume_layout.column_type.tag === "SingleColumn"
         ? width
-        : (width - (0, ResumeLayout_1.vertical_margin)(resume_layout.column_type) / 2.0);
+        : width - (0, ResumeLayout_1.vertical_margin)(resume_layout.column_type) / 2.0;
     const layouts = [];
-    console.error("Rendering sections...");
     for (const section of resume.sections) {
         // Render Section Header
         // 1. Find the layout schema for the section
         console.info("Computing section: ", section.section_name);
-        const layout_schema = layout_schemas
-            .find(s => s.schema_name === section.layout_schema);
+        const layout_schema = layout_schemas.find((s) => s.schema_name === section.layout_schema);
         if (layout_schema === undefined) {
             throw new Error(`Could not find layout schema ${section.layout_schema}`);
         }
@@ -76,14 +81,14 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
         let end_time = Date.now();
         console.info(`Font loading time: ${end_time - start_time}ms for section ${section.section_name}`);
         // 2. Find the data schema for the section
-        const data_schema = data_schemas.find(s => s.schema_name === section.data_schema);
+        const data_schema = data_schemas.find((s) => s.schema_name === section.data_schema);
         if (data_schema === undefined) {
             throw new Error(`Could not find data schema ${section.data_schema}`);
         }
         start_time = Date.now();
         // 3. Render the header
         const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.header_layout_schema, section.data, data_schema.header_schema), column_width, fontDict), fontDict);
-        layout.path = { tag: 'section', section: section.section_name };
+        layout.path = { tag: "section", section: section.section_name };
         console.info("Header is computed");
         layouts.push(layout);
         end_time = Date.now();
@@ -93,7 +98,7 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
         for (const [index, item] of section.items.entries()) {
             // 3. Render the item
             const layout = _1.Layout.computeBoxes(_1.Layout.normalize(_1.Layout.instantiate(layout_schema.item_layout_schema, item.fields, data_schema.item_schema), column_width, fontDict), fontDict);
-            layout.path = { tag: 'item', section: section.section_name, item: index };
+            layout.path = { tag: "item", section: section.section_name, item: index };
             layouts.push(layout);
         }
         end_time = Date.now();
@@ -102,4 +107,3 @@ async function render({ resume, layout_schemas, data_schemas, resume_layout, sto
     console.log("Position calculations are completed.");
     return layouts;
 }
-exports.render = render;

package/dist/BrowserStorage.d.ts

@@ -0,0 +1,22 @@
+import { DataSchema } from "./DataSchema";
+import * as Font from "./Font";
+import { LayoutSchema } from "./LayoutSchema";
+import { Resume } from "./Resume";
+import { ResumeLayout } from "./ResumeLayout";
+import { Storage } from "./Storage";
+export declare class BrowserStorage implements Storage {
+    initiate_storage(): Promise<void>;
+    list_resumes(): Promise<string[]>;
+    list_data_schemas(): Promise<string[]>;
+    list_layout_schemas(): Promise<string[]>;
+    list_resume_layouts(): Promise<string[]>;
+    load_resume(resume_name: string): Promise<Resume>;
+    load_data_schema(schema_name: string): Promise<DataSchema>;
+    load_layout_schema(schema_name: string): Promise<LayoutSchema>;
+    load_resume_layout(schema_name: string): Promise<ResumeLayout>;
+    save_resume(resume_name: string, resume_data: Resume): Promise<void>;
+    save_data_schema(data_schema: DataSchema): Promise<void>;
+    save_layout_schema(layout_schema: LayoutSchema): Promise<void>;
+    save_resume_layout(resume_layout: ResumeLayout): Promise<void>;
+    load_font(font: Font.t): Promise<Buffer>;
+}

package/dist/BrowserStorage.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserStorage = void 0;
+const LocalStorage_1 = require("./LocalStorage");
+const IndexedDB_1 = require("./IndexedDB");
+class BrowserStorage {
+    async initiate_storage() {
+        new LocalStorage_1.LocalStorage().initiate_storage();
+    }
+    list_resumes() {
+        return new LocalStorage_1.LocalStorage().list_resumes();
+    }
+    list_data_schemas() {
+        return new LocalStorage_1.LocalStorage().list_data_schemas();
+    }
+    list_layout_schemas() {
+        return new LocalStorage_1.LocalStorage().list_layout_schemas();
+    }
+    list_resume_layouts() {
+        return new LocalStorage_1.LocalStorage().list_resume_layouts();
+    }
+    load_resume(resume_name) {
+        return new LocalStorage_1.LocalStorage().load_resume(resume_name);
+    }
+    load_data_schema(schema_name) {
+        return new LocalStorage_1.LocalStorage().load_data_schema(schema_name);
+    }
+    load_layout_schema(schema_name) {
+        return new LocalStorage_1.LocalStorage().load_layout_schema(schema_name);
+    }
+    load_resume_layout(schema_name) {
+        return new LocalStorage_1.LocalStorage().load_resume_layout(schema_name);
+    }
+    save_resume(resume_name, resume_data) {
+        return new LocalStorage_1.LocalStorage().save_resume(resume_name, resume_data);
+    }
+    save_data_schema(data_schema) {
+        return new LocalStorage_1.LocalStorage().save_data_schema(data_schema);
+    }
+    save_layout_schema(layout_schema) {
+        return new LocalStorage_1.LocalStorage().save_layout_schema(layout_schema);
+    }
+    save_resume_layout(resume_layout) {
+        throw new Error("Method not implemented.");
+    }
+    async load_font(font) {
+        return new IndexedDB_1.IndexedDB().load_font(font);
+    }
+}
+exports.BrowserStorage = BrowserStorage;

package/dist/DataSchema.js

@@ -16,10 +16,9 @@ var DateFormat;
         "Mon YYYY",
         "Mon DD, YYYY",
         "YYYY",
-        "unknown"
+        "unknown",
     ];
     DateFormat.print = (date, format) => {
-        console.error(date);
         const d = new Date(date + "T00:00:00");
         const year = d.getFullYear();
         const month = d.getMonth() + 1;
@@ -29,13 +28,12 @@ var DateFormat;
         result = result.replace("YY", year.toString().slice(-2));
         result = result.replace("MM", month.toString().padStart(2, "0"));
         result = result.replace("DD", day.toString().padStart(2, "0"));
-        result = result.replace("Month", d.toLocaleString('default', { month: 'long' }));
-        result = result.replace("Mon", d.toLocaleString('default', { month: 'short' }));
+        result = result.replace("Month", d.toLocaleString("default", { month: "long" }));
+        result = result.replace("Mon", d.toLocaleString("default", { month: "short" }));
         return result;
     };
     DateFormat.parse = (date) => {
         const d = new Date(date + "T00:00:00");
-        console.error(d);
         if (isNaN(d.getTime())) {
             return "";
         }
@@ -46,7 +44,10 @@ var DocumentDataType;
 (function (DocumentDataType) {
     function parse(s) {
         if (s === "Date") {
-            return { tag: "Date", format: s.length > 4 ? s.slice(5, -1).trim() : "YYYY-MM-DD" };
+            return {
+                tag: "Date",
+                format: s.length > 4 ? s.slice(5, -1).trim() : "YYYY-MM-DD",
+            };
         }
         else if (s === "String") {
             return { tag: "String" };
@@ -61,7 +62,13 @@ var DocumentDataType;
             return { tag: "List", value: parse(s.slice(5, -1).trim()) };
         }
         else if (s.includes("|")) {
-            return { tag: "Types", value: s.split("|").map((s) => s.trim()).map(parse) };
+            return {
+                tag: "Types",
+                value: s
+                    .split("|")
+                    .map((s) => s.trim())
+                    .map(parse),
+            };
         }
         else {
             throw new Error("Invalid DocumentDataType: " + s);
@@ -127,7 +134,9 @@ class DataSchema {
         if (typeof json !== "object" || json === null) {
             throw new Error("DataSchema must be an object");
         }
-        if (!("schema_name" in json) || !("header_schema" in json) || !("item_schema" in json)) {
+        if (!("schema_name" in json) ||
+            !("header_schema" in json) ||
+            !("item_schema" in json)) {
             throw new Error("DataSchema must have a schema_name, header_schema, and item_schema");
         }
         return new DataSchema(json.schema_name, json.header_schema.map(Field.fromJson), json.item_schema.map(Field.fromJson));

package/dist/Elem.d.ts

@@ -40,7 +40,7 @@ export declare function copy(e: Elem): {
     item: string;
     text?: string;
     spans?: Span[];
-    url: string;
+    url: string | null;
     is_ref: boolean;
     is_fill: boolean;
     is_markdown: boolean;

package/dist/Elem.js

@@ -23,7 +23,26 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.instantiate = exports.boundWidth = exports.fillFonts = exports.parseMarkdownItem = exports.scaleWidth = exports.withBackgroundColor = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withFont = exports.withTextWidth = exports.withIsFill = exports.asRef = exports.withIsRef = exports.withUrl = exports.withItem = exports.from = exports.default_ = exports.copy = exports.elem = void 0;
+exports.elem = elem;
+exports.copy = copy;
+exports.default_ = default_;
+exports.from = from;
+exports.withItem = withItem;
+exports.withUrl = withUrl;
+exports.withIsRef = withIsRef;
+exports.asRef = asRef;
+exports.withIsFill = withIsFill;
+exports.withTextWidth = withTextWidth;
+exports.withFont = withFont;
+exports.withMargin = withMargin;
+exports.withAlignment = withAlignment;
+exports.withWidth = withWidth;
+exports.withBackgroundColor = withBackgroundColor;
+exports.scaleWidth = scaleWidth;
+exports.parseMarkdownItem = parseMarkdownItem;
+exports.fillFonts = fillFonts;
+exports.boundWidth = boundWidth;
+exports.instantiate = instantiate;
 const Font = __importStar(require("./Font"));
 const _1 = require(".");
 const Resume_1 = require("./Resume");
@@ -54,11 +73,9 @@ function elem(item, url, is_ref, is_fill, is_markdown, text_width, font, margin,
         background_color,
     };
 }
-exports.elem = elem;
 function copy(e) {
     return { ...e };
 }
-exports.copy = copy;
 function default_() {
     return {
         tag: "Elem",
@@ -75,59 +92,45 @@ function default_() {
         background_color: "Transparent",
     };
 }
-exports.default_ = default_;
 function from(w) {
     return { ...default_(), ...w };
 }
-exports.from = from;
 function withItem(e, item) {
     return { ...e, item };
 }
-exports.withItem = withItem;
 function withUrl(e, url) {
     return { ...e, url };
 }
-exports.withUrl = withUrl;
 function withIsRef(e, is_ref) {
     return { ...e, is_ref };
 }
-exports.withIsRef = withIsRef;
 function asRef(e) {
     return withIsRef(e, true);
 }
-exports.asRef = asRef;
 function withIsFill(e, is_fill) {
     return { ...e, is_fill };
 }
-exports.withIsFill = withIsFill;
 function withTextWidth(e, text_width) {
     return { ...e, text_width };
 }
-exports.withTextWidth = withTextWidth;
 function withFont(e, font) {
     return { ...e, font };
 }
-exports.withFont = withFont;
 function withMargin(e, margin) {
     return { ...e, margin };
 }
-exports.withMargin = withMargin;
 function withAlignment(e, alignment) {
     return { ...e, alignment };
 }
-exports.withAlignment = withAlignment;
 function withWidth(e, width) {
     return { ...e, width };
 }
-exports.withWidth = withWidth;
 function withBackgroundColor(e, background_color) {
     return { ...e, background_color };
 }
-exports.withBackgroundColor = withBackgroundColor;
 function scaleWidth(e, scale) {
     return withWidth(e, _1.Width.scale(e.width, scale));
 }
-exports.scaleWidth = scaleWidth;
 function flatten(ts, sp) {
     const spans = [];
     for (const t of ts) {
@@ -179,15 +182,16 @@ function parseMarkdownItem(item) {
     }
     return spans;
 }
-exports.parseMarkdownItem = parseMarkdownItem;
 function fillFonts(e, fonts) {
     const simpleSpans = e.is_markdown ? parseMarkdownItem(e.text) : [{ ...defaultSpanProps(), text: e.text, font: e.font, link: null }];
     const spans = [];
     for (const span of simpleSpans) {
         const font = e.is_markdown ? (0, Utils_1.with_)(e.font, ({
-            // style: span.is_italic ? "Italic" : "Normal",
-            weight: span.is_bold ? "Bold" : "Medium",
+            style: span.is_italic ? "Italic" : e.font.style,
+            weight: span.is_bold ? "Bold" : e.font.weight,
+            name: span.is_code ? "JetBrainsMono" : e.font.name
         })) : e.font;
+        console.log(`Font: ${JSON.stringify(font)}`, span.text);
         if (span.text === " ") {
             const width = Font.get_width(font, "-", fonts);
             spans.push({ ...span, font, width });
@@ -202,7 +206,12 @@ function fillFonts(e, fonts) {
             const width = Font.get_width(font, word, fonts);
             spans.push({ ...span, text: word, font, width });
             if (index < words.length - 1) {
-                spans.push({ ...span, text: " ", font, width: Font.get_width(font, " ", fonts) });
+                spans.push({
+                    ...span,
+                    text: " ",
+                    font,
+                    width: Font.get_width(font, " ", fonts),
+                });
             }
         });
     }
@@ -211,14 +220,13 @@ function fillFonts(e, fonts) {
         return (0, Utils_1.with_)(e, {
             width: _1.Width.absolute(Math.min(_1.Width.get_fixed_unchecked(e.width), text_width)),
             text_width: _1.Width.absolute(text_width),
-            spans
+            spans,
         });
     }
     else {
         return (0, Utils_1.with_)(e, { text_width: _1.Width.absolute(text_width), spans });
     }
 }
-exports.fillFonts = fillFonts;
 function boundWidth(e, width) {
     if (!_1.Width.is_fill(e.width)) {
         return withIsFill(withWidth(e, _1.Width.absolute(Math.min(_1.Width.get_fixed_unchecked(e.width), width))), false);
@@ -227,12 +235,11 @@ function boundWidth(e, width) {
         return withIsFill(withWidth(e, _1.Width.absolute(width)), true);
     }
 }
-exports.boundWidth = boundWidth;
 function instantiate(e, section, fields) {
     if (!e.is_ref) {
         return e;
     }
-    const itemType = fields.find(f => f.name === e.item);
+    const itemType = fields.find((f) => f.name === e.item);
     if (itemType.type.tag === "MarkdownString") {
         e.is_markdown = true;
     }
@@ -243,11 +250,14 @@ function instantiate(e, section, fields) {
     }
     else {
         if (text.tag === "Url") {
-            return (0, Utils_1.with_)(e, { is_ref: false, text: text.value.text, url: text.value.url });
+            return (0, Utils_1.with_)(e, {
+                is_ref: false,
+                text: text.value.text,
+                url: text.value.url,
+            });
         }
         else {
             return (0, Utils_1.with_)(e, { is_ref: false, text: Resume_1.ItemContent.toString(text) });
         }
     }
 }
-exports.instantiate = instantiate;

package/dist/FileStorage.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Resume } from "./Resume";
 import { DataSchema } from "./DataSchema";
 import { LayoutSchema } from "./LayoutSchema";

package/dist/FileStorage.js

@@ -81,7 +81,7 @@ class FileStorage {
     }
     async list_resumes() {
         const files = fs_1.default.readdirSync(this.dir + "/resumes");
-        return Promise.resolve(files.map(file => file.replace(".json", "")));
+        return Promise.resolve(files.map((file) => file.replace(".json", "")));
     }
     async list_data_schemas() {
         const data_schemas = fs_1.default.readFileSync(this.dir + "/data-schemas.json");

package/dist/Font.d.ts

@@ -10,10 +10,14 @@ type Font = t;
 export declare function font(name: string, size: number, weight: FontWeight, style: FontStyle, source: FontSource): Font;
 export declare function fromJson(json: unknown): Font;
 export declare function default_(): Font;
+export declare function variants(f: Font): Font[];
 export declare function full_name(f: Font): string;
 export declare function get_width(f: Font, text: string, fonts: FontDict): number;
 export declare function get_height(f: Font, fonts: FontDict): number;
 export type FontSource = "Local" | "System" | "Remote";
-export type FontWeight = "Light" | "Medium" | "Bold";
+export type FontWeight = "ExtraLight" | "Light" | "Thin" | "Medium" | "Regular" | "SemiBold" | "Bold" | "Black" | "ExtraBold";
+export declare const FontWeights: readonly ["ExtraLight", "Light", "Thin", "Medium", "Regular", "SemiBold", "Bold", "Black", "ExtraBold"];
 export type FontStyle = "Normal" | "Italic";
+export declare const FontStyles: readonly ["Normal", "Italic"];
+export declare const AvailableFonts: readonly ["EBGaramond", "Exo", "Inter", "JetBrainsMono", "Montserrat", "Merriweather", "NotoSerif", "OpenSans", "Roboto", "RobotoMono"];
 export {};

package/dist/Font.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.get_height = exports.get_width = exports.full_name = exports.default_ = exports.fromJson = exports.font = void 0;
+exports.AvailableFonts = exports.FontStyles = exports.FontWeights = void 0;
+exports.font = font;
+exports.fromJson = fromJson;
+exports.default_ = default_;
+exports.variants = variants;
+exports.full_name = full_name;
+exports.get_width = get_width;
+exports.get_height = get_height;
 function font(name, size, weight, style, source) {
     return {
         name,
@@ -10,7 +17,6 @@ function font(name, size, weight, style, source) {
         source,
     };
 }
-exports.font = font;
 function fromJson(json) {
     return {
         ...default_(),
@@ -21,7 +27,6 @@ function fromJson(json) {
         source: json["source"],
     };
 }
-exports.fromJson = fromJson;
 function default_() {
     return {
         name: "Exo",
@@ -31,18 +36,58 @@ function default_() {
         source: "System",
     };
 }
-exports.default_ = default_;
+function variants(f) {
+    const fonts = [];
+    for (const weight of exports.FontWeights) {
+        for (const style of exports.FontStyles) {
+            fonts.push({
+                ...f,
+                weight,
+                style,
+            });
+        }
+    }
+    return fonts;
+}
 function full_name(f) {
     return f.name + "-" + f.weight + (f.style === "Italic" ? "Italic" : "");
 }
-exports.full_name = full_name;
 function get_width(f, text, fonts) {
     const font = fonts.get_font(full_name(f));
-    return (font.layout(text).glyphs.reduce((acc, glyph) => acc + glyph.advanceWidth, 0) / font.unitsPerEm) * f.size;
+    return ((font
+        .layout(text)
+        .glyphs.reduce((acc, glyph) => acc + glyph.advanceWidth, 0) /
+        font.unitsPerEm) *
+        f.size);
 }
-exports.get_width = get_width;
 function get_height(f, fonts) {
     const font = fonts.get_font(full_name(f));
     return (font.bbox.height / font.unitsPerEm) * f.size;
 }
-exports.get_height = get_height;
+exports.FontWeights = [
+    "ExtraLight",
+    "Light",
+    "Thin",
+    "Medium",
+    "Regular",
+    "SemiBold",
+    "Bold",
+    "Black",
+    "ExtraBold",
+];
+exports.FontStyles = [
+    "Normal",
+    "Italic",
+];
+exports.AvailableFonts = [
+    "EBGaramond",
+    "Exo",
+    "Inter",
+    "JetBrainsMono",
+    "Montserrat",
+    "Merriweather",
+    "NotoSerif",
+    "OpenSans",
+    "Roboto",
+    "RobotoMono",
+];

package/dist/IndexedDB.d.ts

@@ -0,0 +1,22 @@
+import { DataSchema } from "./DataSchema";
+import * as Font from "./Font";
+import { LayoutSchema } from "./LayoutSchema";
+import { Resume } from "./Resume";
+import { ResumeLayout } from "./ResumeLayout";
+import { Storage } from "./Storage";
+export declare class IndexedDB implements Storage {
+    initiate_storage(): Promise<void>;
+    list_resumes(): Promise<string[]>;
+    list_data_schemas(): Promise<string[]>;
+    list_layout_schemas(): Promise<string[]>;
+    list_resume_layouts(): Promise<string[]>;
+    load_resume(resume_name: string): Promise<Resume>;
+    load_data_schema(schema_name: string): Promise<DataSchema>;
+    load_layout_schema(schema_name: string): Promise<LayoutSchema>;
+    load_resume_layout(schema_name: string): Promise<ResumeLayout>;
+    save_resume(resume_name: string, resume_data: Resume): Promise<void>;
+    save_data_schema(data_schema: DataSchema): Promise<void>;
+    save_layout_schema(layout_schema: LayoutSchema): Promise<void>;
+    save_resume_layout(resume_layout: ResumeLayout): Promise<void>;
+    load_font(font: Font.t): Promise<Buffer>;
+}