markdown-patch 0.1.3 → 0.2.1

package/dist/tests/patch.test.js

@@ -1,65 +1,60 @@
 import fs from "fs";
 import path from "path";
 import { applyPatch, PatchFailed } from "../patch";
-import { ContentType } from "../constants";
+import { ContentType } from "../types";
 describe("patch", () => {
     const sample = fs.readFileSync(path.join(__dirname, "sample.md"), "utf-8");
+    const assertPatchResultsMatch = (inputDocumentPath, outputDocumentPath, instruction) => {
+        const inputDocument = fs.readFileSync(path.join(__dirname, inputDocumentPath), "utf-8");
+        const outputDocument = fs.readFileSync(path.join(__dirname, outputDocumentPath), "utf-8");
+        expect(applyPatch(inputDocument, instruction)).toEqual(outputDocument);
+    };
     describe("heading", () => {
         test("prepend", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.prepend.md"), "utf-8");
             const instruction = {
                 targetType: "heading",
                 target: ["Overview"],
                 operation: "prepend",
                 content: "Beep Boop\n",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.heading.prepend.md", instruction);
         });
         test("append", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.append.md"), "utf-8");
             const instruction = {
                 targetType: "heading",
                 target: ["Overview"],
                 operation: "append",
                 content: "Beep Boop\n",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.heading.append.md", instruction);
         });
         test("replace", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.replace.md"), "utf-8");
             const instruction = {
                 targetType: "heading",
                 target: ["Overview"],
                 operation: "replace",
                 content: "Beep Boop\n",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.heading.replace.md", instruction);
         });
         describe("document", () => {
             test("prepend", () => {
-                const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.document.prepend.md"), "utf-8");
                 const instruction = {
                     targetType: "heading",
                     target: null,
                     operation: "prepend",
                     content: "Beep Boop\n",
                 };
-                const actualResult = applyPatch(sample, instruction);
-                expect(actualResult).toEqual(expected);
+                assertPatchResultsMatch("sample.md", "sample.patch.heading.document.prepend.md", instruction);
             });
             test("append", () => {
-                const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.document.append.md"), "utf-8");
                 const instruction = {
                     targetType: "heading",
                     target: null,
                     operation: "append",
                     content: "Beep Boop\n",
                 };
-                const actualResult = applyPatch(sample, instruction);
-                expect(actualResult).toEqual(expected);
+                assertPatchResultsMatch("sample.md", "sample.patch.heading.document.append.md", instruction);
             });
         });
     });
@@ -67,7 +62,6 @@ describe("patch", () => {
         describe("trimTargetWhitespace", () => {
             describe("heading", () => {
                 test("prepend", () => {
-                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.trimTargetWhitespace.prepend.md"), "utf-8");
                     const instruction = {
                         targetType: "heading",
                         target: ["Page Targets", "Document Properties (Exploratory)"],
@@ -75,11 +69,9 @@ describe("patch", () => {
                         content: "Beep Boop",
                         trimTargetWhitespace: true,
                     };
-                    const actualResult = applyPatch(sample, instruction);
-                    expect(actualResult).toEqual(expected);
+                    assertPatchResultsMatch("sample.md", "sample.patch.heading.trimTargetWhitespace.prepend.md", instruction);
                 });
                 test("append", () => {
-                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.trimTargetWhitespace.append.md"), "utf-8");
                     const instruction = {
                         targetType: "heading",
                         target: ["Problems"],
@@ -87,11 +79,32 @@ describe("patch", () => {
                         content: "Beep Boop\n",
                         trimTargetWhitespace: true,
                     };
-                    const actualResult = applyPatch(sample, instruction);
-                    expect(actualResult).toEqual(expected);
+                    assertPatchResultsMatch("sample.md", "sample.patch.heading.trimTargetWhitespace.append.md", instruction);
                 });
             });
         });
+        describe("createTargetIfMissing", () => {
+            test("nested", () => {
+                const instruction = {
+                    targetType: "heading",
+                    target: ["Page Targets", "Block", "Test"],
+                    operation: "replace",
+                    content: "Beep Boop\n",
+                    createTargetIfMissing: true,
+                };
+                assertPatchResultsMatch("sample.md", "sample.patch.heading.createIfMissing.nested.md", instruction);
+            });
+            test("root", () => {
+                const instruction = {
+                    targetType: "heading",
+                    target: ["Alpha", "Beta", "Test"],
+                    operation: "replace",
+                    content: "Beep Boop\n",
+                    createTargetIfMissing: true,
+                };
+                assertPatchResultsMatch("sample.md", "sample.patch.heading.createIfMissing.root.md", instruction);
+            });
+        });
         describe("applyIfContentPreexists", () => {
             describe("disabled (default)", () => {
                 describe("heading", () => {
@@ -141,81 +154,296 @@ describe("patch", () => {
     });
     describe("block", () => {
         test("prepend", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.prepend.md"), "utf-8");
             const instruction = {
                 targetType: "block",
                 target: "e6068e",
                 operation: "prepend",
                 content: "- OK\n",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.block.prepend.md", instruction);
         });
         test("append", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.append.md"), "utf-8");
             const instruction = {
                 targetType: "block",
                 target: "e6068e",
                 operation: "append",
                 content: "\n- OK",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.block.append.md", instruction);
         });
         test("replace", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.replace.md"), "utf-8");
             const instruction = {
                 targetType: "block",
                 target: "259a73",
                 operation: "replace",
                 content: "- OK",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.block.replace.md", instruction);
         });
         describe("tagetBlockTypeBehavior", () => {
             describe("table", () => {
                 test("prepend", () => {
-                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.targetBlockTypeBehavior.table.prepend.md"), "utf-8");
                     const instruction = {
                         targetType: "block",
                         target: "2c67a6",
                         operation: "prepend",
-                        contentType: ContentType.tableRows,
+                        contentType: ContentType.json,
                         content: [
                             ["`something else`", "Some other application", "✅", "✅", "✅"],
                         ],
                     };
-                    const actualResult = applyPatch(sample, instruction);
-                    expect(actualResult).toEqual(expected);
+                    assertPatchResultsMatch("sample.md", "sample.patch.block.targetBlockTypeBehavior.table.prepend.md", instruction);
                 });
                 test("append", () => {
-                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.targetBlockTypeBehavior.table.append.md"), "utf-8");
                     const instruction = {
                         targetType: "block",
                         target: "2c67a6",
                         operation: "append",
-                        contentType: ContentType.tableRows,
+                        contentType: ContentType.json,
                         content: [
                             ["`something else`", "Some other application", "✅", "✅", "✅"],
                         ],
                     };
-                    const actualResult = applyPatch(sample, instruction);
-                    expect(actualResult).toEqual(expected);
+                    assertPatchResultsMatch("sample.md", "sample.patch.block.targetBlockTypeBehavior.table.append.md", instruction);
                 });
                 test("replace", () => {
-                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.targetBlockTypeBehavior.table.replace.md"), "utf-8");
                     const instruction = {
                         targetType: "block",
                         target: "2c67a6",
                         operation: "replace",
-                        contentType: ContentType.tableRows,
+                        contentType: ContentType.json,
                         content: [
                             ["`something else`", "Some other application", "✅", "✅", "✅"],
                         ],
                     };
-                    const actualResult = applyPatch(sample, instruction);
-                    expect(actualResult).toEqual(expected);
+                    assertPatchResultsMatch("sample.md", "sample.patch.block.targetBlockTypeBehavior.table.replace.md", instruction);
+                });
+            });
+        });
+    });
+    describe("frontmatter", () => {
+        describe("append", () => {
+            test("mismatched types", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "append",
+                    contentType: ContentType.json,
+                    content: "OK",
+                };
+                expect(() => {
+                    applyPatch(sample, instruction);
+                }).toThrow(PatchFailed);
+            });
+            test("invalid type", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "append",
+                    contentType: ContentType.json,
+                    content: 10,
+                };
+                expect(() => {
+                    applyPatch(sample, instruction);
+                }).toThrow(PatchFailed);
+            });
+            test("list", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "append",
+                    contentType: ContentType.json,
+                    content: ["Beep"],
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.append.list.md", instruction);
+            });
+            test("dictionary", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "object-value",
+                    operation: "append",
+                    contentType: ContentType.json,
+                    content: { three: "Beep" },
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.append.dictionary.md", instruction);
+            });
+            test("string", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "string-value",
+                    operation: "append",
+                    contentType: ContentType.json,
+                    content: "Beep",
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.append.string.md", instruction);
+            });
+        });
+        describe("prepend", () => {
+            test("mismatched types", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "prepend",
+                    contentType: ContentType.json,
+                    content: "OK",
+                };
+                expect(() => {
+                    applyPatch(sample, instruction);
+                }).toThrow(PatchFailed);
+            });
+            test("invalid type", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "prepend",
+                    contentType: ContentType.json,
+                    content: 10,
+                };
+                expect(() => {
+                    applyPatch(sample, instruction);
+                }).toThrow(PatchFailed);
+            });
+            test("list", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "prepend",
+                    contentType: ContentType.json,
+                    content: ["Beep"],
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.prepend.list.md", instruction);
+            });
+            test("dictionary", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "object-value",
+                    operation: "prepend",
+                    contentType: ContentType.json,
+                    content: { three: "Beep" },
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.prepend.dictionary.md", instruction);
+            });
+            test("string", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "string-value",
+                    operation: "prepend",
+                    contentType: ContentType.json,
+                    content: "Beep",
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.prepend.string.md", instruction);
+            });
+        });
+        describe("replace", () => {
+            test("list", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "replace",
+                    contentType: ContentType.json,
+                    content: ["Replaced"],
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.replace.list.md", instruction);
+            });
+            test("dictionary", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "object-value",
+                    operation: "replace",
+                    contentType: ContentType.json,
+                    content: {
+                        replaced: true,
+                    },
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.replace.dictionary.md", instruction);
+            });
+            test("string", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "string-value",
+                    operation: "replace",
+                    contentType: ContentType.json,
+                    content: "Replaced",
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.replace.string.md", instruction);
+            });
+            test("number", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "number-value",
+                    operation: "replace",
+                    contentType: ContentType.json,
+                    content: 10,
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.replace.number.md", instruction);
+            });
+            test("boolean", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "boolean-value",
+                    operation: "replace",
+                    contentType: ContentType.json,
+                    content: true,
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.replace.boolean.md", instruction);
+            });
+            describe("createTargetIfMissing", () => {
+                test("list", () => {
+                    const instruction = {
+                        targetType: "frontmatter",
+                        target: "new-field",
+                        operation: "replace",
+                        contentType: ContentType.json,
+                        content: ["New Value"],
+                        createTargetIfMissing: true,
+                    };
+                    assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.createTargetIfMissing.list.md", instruction);
+                });
+                test("dictionary", () => {
+                    const instruction = {
+                        targetType: "frontmatter",
+                        target: "new-field",
+                        operation: "replace",
+                        contentType: ContentType.json,
+                        content: {
+                            newValue: true,
+                        },
+                        createTargetIfMissing: true,
+                    };
+                    assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.createTargetIfMissing.dictionary.md", instruction);
+                });
+                test("string", () => {
+                    const instruction = {
+                        targetType: "frontmatter",
+                        target: "new-field",
+                        operation: "replace",
+                        contentType: ContentType.json,
+                        content: "New Value",
+                        createTargetIfMissing: true,
+                    };
+                    assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.createTargetIfMissing.string.md", instruction);
+                });
+                test("number", () => {
+                    const instruction = {
+                        targetType: "frontmatter",
+                        target: "new-field",
+                        operation: "replace",
+                        contentType: ContentType.json,
+                        content: 588600,
+                        createTargetIfMissing: true,
+                    };
+                    assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.createTargetIfMissing.number.md", instruction);
+                });
+                test("boolean", () => {
+                    const instruction = {
+                        targetType: "frontmatter",
+                        target: "new-field",
+                        operation: "replace",
+                        contentType: ContentType.json,
+                        content: true,
+                        createTargetIfMissing: true,
+                    };
+                    assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.createTargetIfMissing.boolean.md", instruction);
                 });
             });
         });

package/dist/typeGuards.d.ts

@@ -0,0 +1,7 @@
+import { AppendableFrontmatterType } from "./types";
+export declare function isStringArrayArray(obj: unknown): obj is string[][];
+export declare function isAppendableFrontmatterType(obj: unknown): obj is AppendableFrontmatterType;
+export declare function isString(obj: unknown): obj is string;
+export declare function isDictionary(obj: unknown): obj is Record<string, unknown>;
+export declare function isList(obj: unknown): obj is Array<unknown>;
+//# sourceMappingURL=typeGuards.d.ts.map

package/dist/typeGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["../src/typeGuards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEpD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,EAAE,EAAE,CAUlE;AACD,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,OAAO,GACX,GAAG,IAAI,yBAAyB,CAElC;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAEpD;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAE1D"}

package/dist/typeGuards.js

@@ -0,0 +1,20 @@
+export function isStringArrayArray(obj) {
+    // Check if the object is an array
+    if (!Array.isArray(obj))
+        return false;
+    // Check if every element is an array of strings
+    return obj.every((item) => Array.isArray(item) &&
+        item.every((subItem) => typeof subItem === "string"));
+}
+export function isAppendableFrontmatterType(obj) {
+    return isString(obj) || isDictionary(obj) || isList(obj);
+}
+export function isString(obj) {
+    return typeof obj === "string";
+}
+export function isDictionary(obj) {
+    return typeof obj === "object" && obj !== null && !Array.isArray(obj);
+}
+export function isList(obj) {
+    return Array.isArray(obj);
+}

package/dist/types.d.ts

@@ -1,4 +1,3 @@
-import { ContentType } from "./constants";
 export interface DocumentRange {
     start: number;
     end: number;
@@ -13,12 +12,16 @@ export interface HeadingMarkerContentPair extends DocumentMapMarkerContentPair {
 export interface DocumentMap {
     heading: Record<string, HeadingMarkerContentPair>;
     block: Record<string, DocumentMapMarkerContentPair>;
+    frontmatter: Record<string, any>;
+    contentOffset: number;
+    lineEnding: string;
 }
-export type PatchTargetType = "heading" | "block";
+export type PatchTargetType = "heading" | "block" | "frontmatter";
 export type PatchOperation = "replace" | "prepend" | "append";
 export interface BasePatchInstructionTarget {
     targetType: PatchTargetType;
     target: any;
+    createTargetIfMissing?: boolean;
 }
 export interface BasePatchInstructionOperation {
     operation: string;
@@ -27,13 +30,17 @@ export interface BaseHeadingPatchInstruction extends BasePatchInstructionTarget
     targetType: "heading";
     target: string[] | null;
 }
+export interface BaseFrontmatterPatchInstruction extends BasePatchInstructionTarget {
+    targetType: "frontmatter";
+    target: string;
+}
 export interface BaseBlockPatchInstruction extends BasePatchInstructionTarget {
     targetType: "block";
     target: string;
 }
 export interface NonExtendingPatchInstruction extends BasePatchInstructionOperation {
 }
-export interface ExtendingPatchInstruction extends BasePatchInstructionOperation {
+export interface TextExtendingPatchInstruction extends BasePatchInstructionOperation {
     /** Trim whitepsace from target before joining with content
      *
      * - For `prepend`: Trims content from the beginning of
@@ -58,38 +65,135 @@ export interface StringContent {
     contentType?: ContentType.text;
     content: string;
 }
-export interface TableRowsContent {
-    contentType: ContentType.tableRows;
-    content: string[][];
+export interface JsonContent {
+    contentType: ContentType.json;
+    content: unknown;
 }
-export interface PrependHeadingPatchInstruction extends ExtendingPatchInstruction, BaseHeadingPatchInstruction, StringContent {
+/**
+ * Prepend content to content existing under a heading
+ *
+ * @category Patch Instructions
+ */
+export interface PrependHeadingPatchInstruction extends TextExtendingPatchInstruction, BaseHeadingPatchInstruction, StringContent {
     operation: "prepend";
 }
-export interface AppendHeadingPatchInstruction extends ExtendingPatchInstruction, BaseHeadingPatchInstruction, StringContent {
+/**
+ * Append content to content existing under a heading
+ *
+ * @category Patch Instructions
+ */
+export interface AppendHeadingPatchInstruction extends TextExtendingPatchInstruction, BaseHeadingPatchInstruction, StringContent {
     operation: "append";
 }
+/**
+ * Replace content under a heading
+ *
+ * @category Patch Instructions
+ */
 export interface ReplaceHeadingPatchInstruction extends NonExtendingPatchInstruction, BaseHeadingPatchInstruction, StringContent {
     operation: "replace";
 }
-export interface PrependBlockPatchInstruction extends ExtendingPatchInstruction, BaseBlockPatchInstruction, StringContent {
+/**
+ * Prepend content to a block referenced by a block reference
+ *
+ * @category Patch Instructions
+ */
+export interface PrependBlockPatchInstruction extends TextExtendingPatchInstruction, BaseBlockPatchInstruction, StringContent {
     operation: "prepend";
 }
-export interface AppendBlockPatchInstruction extends ExtendingPatchInstruction, BaseBlockPatchInstruction, StringContent {
+/**
+ * Append content to a block referenced by a block reference
+ *
+ * @category Patch Instructions
+ */
+export interface AppendBlockPatchInstruction extends TextExtendingPatchInstruction, BaseBlockPatchInstruction, StringContent {
     operation: "append";
 }
+/**
+ * Replace content of block referenced by a block reference.
+ *
+ * @category Patch Instructions
+ */
 export interface ReplaceBlockPatchInstruction extends NonExtendingPatchInstruction, BaseBlockPatchInstruction, StringContent {
     operation: "replace";
 }
-export interface PrependTableRowsBlockPatchInstruction extends ExtendingPatchInstruction, BaseBlockPatchInstruction, TableRowsContent {
+/**
+ * Prepend rows to a table referenced by a block reference.
+ *
+ * @category Patch Instructions
+ */
+export interface PrependTableRowsBlockPatchInstruction extends TextExtendingPatchInstruction, BaseBlockPatchInstruction, JsonContent {
     operation: "prepend";
 }
-export interface AppendTableRowsBlockPatchInstruction extends ExtendingPatchInstruction, BaseBlockPatchInstruction, TableRowsContent {
+/**
+ * Patch Instruction for appending rows to a table
+ * referenced by a block reference.
+ *
+ * @category Patch Instructions
+ */
+export interface AppendTableRowsBlockPatchInstruction extends TextExtendingPatchInstruction, BaseBlockPatchInstruction, JsonContent {
     operation: "append";
 }
-export interface ReplaceTableRowsBlockPatchInstruction extends NonExtendingPatchInstruction, BaseBlockPatchInstruction, TableRowsContent {
+/**
+ * Patch Instruction for replacing all rows of a table
+ * referenced by a block reference.
+ *
+ * @category Patch Instructions
+ */
+export interface ReplaceTableRowsBlockPatchInstruction extends NonExtendingPatchInstruction, BaseBlockPatchInstruction, JsonContent {
     operation: "replace";
 }
+/**
+ * Prepend content to a frontmatter field
+ *
+ * @category Patch Instructions
+ */
+export interface PrependFrontmatterPatchInstruction extends NonExtendingPatchInstruction, BaseFrontmatterPatchInstruction, JsonContent {
+    operation: "prepend";
+}
+/**
+ * Append content to a frontmatter field
+ *
+ * @category Patch Instructions
+ */
+export interface AppendFrontmatterPatchInstruction extends NonExtendingPatchInstruction, BaseFrontmatterPatchInstruction, JsonContent {
+    operation: "append";
+}
+/**
+ * Replace content of frontmatter field
+ *
+ * @category Patch Instructions
+ */
+export interface ReplaceFrontmatterPatchInstruction extends NonExtendingPatchInstruction, BaseFrontmatterPatchInstruction, JsonContent {
+    operation: "replace";
+}
+/**
+ * Patch Instruction for Headings
+ */
 export type HeadingPatchInstruction = PrependHeadingPatchInstruction | AppendHeadingPatchInstruction | ReplaceHeadingPatchInstruction;
+/**
+ * Patch Instruction for Block References
+ */
 export type BlockPatchInstruction = PrependBlockPatchInstruction | AppendBlockPatchInstruction | ReplaceBlockPatchInstruction | PrependTableRowsBlockPatchInstruction | AppendTableRowsBlockPatchInstruction | ReplaceTableRowsBlockPatchInstruction;
-export type PatchInstruction = HeadingPatchInstruction | BlockPatchInstruction;
+export type FrontmatterPatchInstruction = PrependFrontmatterPatchInstruction | AppendFrontmatterPatchInstruction | ReplaceFrontmatterPatchInstruction;
+/**
+ * Patch Instruction
+ */
+export type PatchInstruction = HeadingPatchInstruction | BlockPatchInstruction | FrontmatterPatchInstruction;
+export declare enum ContentType {
+    /**
+     * Content is simple markdown text.
+     */
+    text = "text/markdown",
+    /**
+     * Content is a JSON document
+     */
+    json = "application/json"
+}
+export interface PreprocessedDocument {
+    frontmatter: Record<string, any>;
+    contentOffset: number;
+    content: string;
+}
+export type AppendableFrontmatterType = string | Array<unknown> | Record<string, unknown>;
 //# sourceMappingURL=types.d.ts.map