beancount 0.0.31 → 0.2.0

package/build/src/deserialize.mjs

@@ -1,88 +1,88 @@
-import { entryTypeToClass } from './entryTypeToClass.mjs';
+import { nodeTypeToClass } from './nodeTypeToClass.mjs';
 /**
- * Deserializes a single entry from its JSON representation.
+ * Deserializes a single node from its JSON representation.
  *
  * This function takes a plain JavaScript object (typically from JSON.parse)
- * and reconstructs the appropriate Entry subclass instance. It validates
+ * and reconstructs the appropriate Node subclass instance. It validates
  * the input and provides helpful error messages for common issues.
  *
- * @param entryData - Plain object containing entry data with a 'type' field
- * @returns An Entry instance of the appropriate subclass
- * @throws {Error} If the entry data is invalid:
+ * @param nodeData - Plain object containing node data with a 'type' field
+ * @returns An Node instance of the appropriate subclass
+ * @throws {Error} If the node data is invalid:
  *   - Missing or invalid 'type' field
- *   - Unknown entry type
- *   - Invalid entry structure (errors from Entry.fromJSONData)
+ *   - Unknown node type
+ *   - Invalid node structure (errors from Node.fromJSONData)
  *
  * @example
- * Deserializing a simple entry:
+ * Deserializing a simple node:
  * ```typescript
- * const entryData = {
+ * const nodeData = {
  *   type: 'open',
  *   date: '2024-01-01',
  *   account: 'Assets:Checking'
  * }
- * const entry = deserializeEntry(entryData)
- * console.log(entry.type) // 'open'
+ * const node = deserializeNode(nodeData)
+ * console.log(node.type) // 'open'
  * ```
  *
  * @example
  * Deserializing from JSON.parse:
  * ```typescript
  * const json = '{"type":"balance","date":"2024-01-02","account":"Assets:Checking","amount":"100","currency":"USD"}'
- * const entryData = JSON.parse(json)
- * const entry = deserializeEntry(entryData)
+ * const nodeData = JSON.parse(json)
+ * const node = deserializeNode(nodeData)
  * ```
  */
-export function deserializeEntry(entryData) {
+export function deserializeNode(nodeData) {
     // Validate input is an object
-    if (!entryData || typeof entryData !== 'object') {
-        throw new Error(`Invalid entry data: expected an object but received ${typeof entryData}`);
+    if (!nodeData || typeof nodeData !== 'object') {
+        throw new Error(`Invalid node data: expected an object but received ${typeof nodeData}`);
     }
     // Validate 'type' field exists
-    if (!('type' in entryData)) {
-        throw new Error('Invalid entry data: missing required "type" field. ' +
-            'Entry data must include a "type" property indicating the entry type.');
+    if (!('type' in nodeData)) {
+        throw new Error('Invalid node data: missing required "type" field. ' +
+            'Node data must include a "type" property indicating the node type.');
     }
     // Validate 'type' is a string
-    if (typeof entryData.type !== 'string') {
-        throw new Error(`Invalid entry data: "type" field must be a string, but received ${typeof entryData.type}`);
+    if (typeof nodeData.type !== 'string') {
+        throw new Error(`Invalid node data: "type" field must be a string, but received ${typeof nodeData.type}`);
     }
-    const entryType = entryData.type;
-    // Validate entry type is recognized
-    const EntryClass = entryTypeToClass[entryType];
-    if (!EntryClass) {
-        throw new Error(`Unknown entry type: "${entryType}". ` +
-            `Valid entry types are: ${Object.keys(entryTypeToClass).join(', ')}`);
+    const nodeType = nodeData.type;
+    // Validate node type is recognized
+    const NodeClass = nodeTypeToClass[nodeType];
+    if (!NodeClass) {
+        throw new Error(`Unknown node type: "${nodeType}". ` +
+            `Valid node types are: ${Object.keys(nodeTypeToClass).join(', ')}`);
     }
-    // Attempt to deserialize the entry
+    // Attempt to deserialize the node
     try {
-        return EntryClass.fromJSONData(entryData);
+        return NodeClass.fromJSONData(nodeData);
     }
     catch (error) {
         // Wrap errors from fromJSONData with additional context
         const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to deserialize ${entryType} entry: ${errorMessage}`);
+        throw new Error(`Failed to deserialize ${nodeType} node: ${errorMessage}`);
     }
 }
 /**
- * Deserializes a single entry from a JSON string.
+ * Deserializes a single node from a JSON string.
  *
- * This function parses a JSON string containing an entry object
- * and reconstructs the appropriate Entry subclass instance.
+ * This function parses a JSON string containing an node object
+ * and reconstructs the appropriate Node subclass instance.
  *
- * @param jsonString - JSON string containing an entry object
- * @returns An Entry instance of the appropriate subclass
- * @throws {Error} If the JSON is invalid or entry cannot be deserialized:
+ * @param jsonString - JSON string containing an node object
+ * @returns An Node instance of the appropriate subclass
+ * @throws {Error} If the JSON is invalid or node cannot be deserialized:
  *   - Invalid JSON syntax
  *   - JSON does not contain an object
- *   - Entry validation errors (see deserializeEntry)
+ *   - Node validation errors (see deserializeNode)
  *
  * @example
  * Deserializing from a JSON string:
  * ```typescript
  * const json = '{"type":"open","date":"2024-01-01","account":"Assets:Checking"}'
- * const entry = deserializeEntryFromString(json)
- * console.log(entry.type) // 'open'
+ * const node = deserializeNodeFromString(json)
+ * console.log(node.type) // 'open'
  * ```
  *
  * @example
@@ -90,56 +90,56 @@ export function deserializeEntry(entryData) {
  * ```typescript
  * const original = Open.fromString('2024-01-01 open Assets:Checking')
  * const json = JSON.stringify(original.toJSON())
- * const deserialized = deserializeEntryFromString(json)
+ * const deserialized = deserializeNodeFromString(json)
  * // deserialized equals original
  * ```
  */
-export function deserializeEntryFromString(jsonString) {
+export function deserializeNodeFromString(jsonString) {
     // Validate input
     if (typeof jsonString !== 'string') {
         throw new Error(`Invalid input: expected a JSON string but received ${typeof jsonString}`);
     }
     // Parse JSON with error handling
-    let entryData;
+    let nodeData;
     try {
-        entryData = JSON.parse(jsonString);
+        nodeData = JSON.parse(jsonString);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to parse JSON: ${errorMessage}`);
     }
     // Validate parsed data is an object (not array or null)
-    if (entryData === null || typeof entryData !== 'object') {
-        throw new Error(`Invalid JSON structure: expected an object but received ${entryData === null ? 'null' : typeof entryData}`);
+    if (nodeData === null || typeof nodeData !== 'object') {
+        throw new Error(`Invalid JSON structure: expected an object but received ${nodeData === null ? 'null' : typeof nodeData}`);
     }
-    if (Array.isArray(entryData)) {
+    if (Array.isArray(nodeData)) {
         throw new Error('Invalid JSON structure: expected an object but received an array');
     }
-    return deserializeEntry(entryData);
+    return deserializeNode(nodeData);
 }
 /**
- * Deserializes an array of entries from their JSON representations.
+ * Deserializes an array of nodes from their JSON representations.
  *
  * This function takes an array of plain JavaScript objects (typically from JSON.parse)
- * and reconstructs each as the appropriate Entry subclass instance. It validates
- * the input and provides helpful error messages, including the index of any entry
+ * and reconstructs each as the appropriate Node subclass instance. It validates
+ * the input and provides helpful error messages, including the index of any node
  * that fails to deserialize.
  *
- * @param entriesData - Array of plain objects containing entry data
- * @returns Array of Entry instances
- * @throws {Error} If the input is invalid or entries cannot be deserialized:
+ * @param nodesData - Array of plain objects containing node data
+ * @returns Array of Node instances
+ * @throws {Error} If the input is invalid or nodes cannot be deserialized:
  *   - Input is not an array
- *   - Any entry fails validation (see deserializeEntry)
+ *   - Any node fails validation (see deserializeNode)
  *
  * @example
- * Deserializing an array of entries:
+ * Deserializing an array of nodes:
  * ```typescript
- * const entriesData = [
+ * const nodesData = [
  *   { type: 'open', date: '2024-01-01', account: 'Assets:Checking' },
  *   { type: 'balance', date: '2024-01-02', account: 'Assets:Checking', amount: '100', currency: 'USD' }
  * ]
- * const entries = deserializeEntries(entriesData)
- * console.log(entries.length) // 2
+ * const nodes = deserializeNodes(nodesData)
+ * console.log(nodes.length) // 2
  * ```
  *
  * @example
@@ -148,52 +148,52 @@ export function deserializeEntryFromString(jsonString) {
  * const original = [Open.fromString('2024-01-01 open Assets:Checking')]
  * const json = JSON.stringify(original.map(e => e.toJSON()))
  * const parsed = JSON.parse(json)
- * const deserialized = deserializeEntries(parsed)
+ * const deserialized = deserializeNodes(parsed)
  * // deserialized equals original
  * ```
  */
-export function deserializeEntries(entriesData) {
+export function deserializeNodes(nodesData) {
     // Validate input is an array
-    if (!Array.isArray(entriesData)) {
-        throw new Error(`Invalid input: expected an array but received ${typeof entriesData}`);
+    if (!Array.isArray(nodesData)) {
+        throw new Error(`Invalid input: expected an array but received ${typeof nodesData}`);
     }
-    // Deserialize each entry with error context
-    const entries = [];
-    for (let i = 0; i < entriesData.length; i++) {
+    // Deserialize each node with error context
+    const nodes = [];
+    for (let i = 0; i < nodesData.length; i++) {
         try {
-            entries.push(deserializeEntry(entriesData[i]));
+            nodes.push(deserializeNode(nodesData[i]));
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Failed to deserialize entry at index ${i}: ${errorMessage}`);
+            throw new Error(`Failed to deserialize node at index ${i}: ${errorMessage}`);
         }
     }
-    return entries;
+    return nodes;
 }
 /**
- * Deserializes an array of entries from a JSON string.
+ * Deserializes an array of nodes from a JSON string.
  *
- * This function parses a JSON string containing an array of entry objects
- * and reconstructs each entry as the appropriate Entry subclass instance.
+ * This function parses a JSON string containing an array of node objects
+ * and reconstructs each node as the appropriate Node subclass instance.
  * It validates the input and provides helpful error messages, including
- * the index of any entry that fails to deserialize.
+ * the index of any node that fails to deserialize.
  *
- * @param jsonString - JSON string containing an array of entry objects
- * @returns Array of Entry instances
- * @throws {Error} If the JSON is invalid or entries cannot be deserialized:
+ * @param jsonString - JSON string containing an array of node objects
+ * @returns Array of Node instances
+ * @throws {Error} If the JSON is invalid or nodes cannot be deserialized:
  *   - Invalid JSON syntax
  *   - JSON does not contain an array
- *   - Any entry fails validation (see deserializeEntry)
+ *   - Any node fails validation (see deserializeNode)
  *
  * @example
- * Deserializing multiple entries:
+ * Deserializing multiple nodes:
  * ```typescript
  * const json = '[
  *   {"type": "open", "date": "2024-01-01", "account": "Assets:Checking"},
  *   {"type": "balance", "date": "2024-01-02", "account": "Assets:Checking", "amount": "100", "currency": "USD"}
  * ]'
- * const entries = deserializeEntries(json)
- * console.log(entries.length) // 2
+ * const nodes = deserializeNodes(json)
+ * console.log(nodes.length) // 2
  * ```
  *
  * @example
@@ -202,28 +202,28 @@ export function deserializeEntries(entriesData) {
  * import { parse } from 'beancount'
  *
  * const original = parse('2024-01-01 open Assets:Checking')
- * const json = JSON.stringify(original.entries.map(e => e.toJSON()))
- * const deserialized = deserializeEntries(json)
- * // deserialized equals original.entries
+ * const json = JSON.stringify(original.nodes.map(e => e.toJSON()))
+ * const deserialized = deserializeNodes(json)
+ * // deserialized equals original.nodes
  * ```
  */
-export function deserializeEntriesFromString(jsonString) {
+export function deserializeNodesFromString(jsonString) {
     // Validate input
     if (typeof jsonString !== 'string') {
         throw new Error(`Invalid input: expected a JSON string but received ${typeof jsonString}`);
     }
     // Parse JSON with error handling
-    let entriesData;
+    let nodesData;
     try {
-        entriesData = JSON.parse(jsonString);
+        nodesData = JSON.parse(jsonString);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to parse JSON: ${errorMessage}`);
     }
     // Validate parsed data is an array
-    if (!Array.isArray(entriesData)) {
-        throw new Error(`Invalid JSON structure: expected an array but received ${typeof entriesData}`);
+    if (!Array.isArray(nodesData)) {
+        throw new Error(`Invalid JSON structure: expected an array but received ${typeof nodesData}`);
     }
-    return deserializeEntries(entriesData);
+    return deserializeNodes(nodesData);
 }

package/build/src/directiveTypes.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Array of all Beancount directive types that start with a date (YYYY-MM-DD format).
+ * These directives follow the pattern: `YYYY-MM-DD <type> ...`
+ */
+export declare const DATED_DIRECTIVE_TYPES: readonly ["balance", "close", "commodity", "custom", "document", "event", "note", "open", "pad", "price", "query", "transaction"];
+/**
+ * Array of all Beancount directive types that do NOT start with a date.
+ * These directives follow the pattern: `<type> ...`
+ */
+export declare const NON_DATED_DIRECTIVE_TYPES: readonly ["include", "option", "plugin", "poptag", "pushtag"];

package/build/src/directiveTypes.mjs

@@ -0,0 +1,29 @@
+/**
+ * Array of all Beancount directive types that start with a date (YYYY-MM-DD format).
+ * These directives follow the pattern: `YYYY-MM-DD <type> ...`
+ */
+export const DATED_DIRECTIVE_TYPES = [
+    'balance',
+    'close',
+    'commodity',
+    'custom',
+    'document',
+    'event',
+    'note',
+    'open',
+    'pad',
+    'price',
+    'query',
+    'transaction',
+];
+/**
+ * Array of all Beancount directive types that do NOT start with a date.
+ * These directives follow the pattern: `<type> ...`
+ */
+export const NON_DATED_DIRECTIVE_TYPES = [
+    'include',
+    'option',
+    'plugin',
+    'poptag',
+    'pushtag',
+];

package/build/src/genericParse.d.mts

@@ -1,27 +1,34 @@
-import type { BeancountEntryType, FakeEntryType } from './entryTypeToClass.mjs';
+import type { BeancountDirectiveNodeType, SyntheticNodeType } from './nodeTypeToClass.mjs';
 import { type Metadata } from './utils/parseMetadata.mjs';
 /**
- * The basic result structure from generic parsing of a Beancount entry.
- * Contains the entry type, header line content, and any properties like comments.
+ * The basic result structure from generic parsing of a Beancount directive.
+ * Contains the directive type, header line content, and any properties like comments.
  */
 export interface GenericParseResult {
-    /** The type of Beancount entry (e.g., 'open', 'close', 'balance') */
-    type: BeancountEntryType;
-    /** The main header content from the first line of the entry */
+    /** The type of Beancount directive (e.g., 'open', 'close', 'balance') */
+    type: BeancountDirectiveNodeType;
+    /** The main header content from the first line of the directive */
     header: string;
-    /** Properties extracted from the entry */
+    /** Properties extracted from the directive */
     props: {
         /** Optional comment text following a semicolon */
         comment?: string;
     };
-    fake?: false;
+    synthetic?: false;
 }
-export interface GenericParseResultFakeEntry extends Omit<GenericParseResult, 'fake' | 'type'> {
-    type: FakeEntryType;
-    fake: true;
+/**
+ * Generic parse result for synthetic (non-directive) nodes.
+ * These represent content that doesn't correspond to actual Beancount directives,
+ * such as comments and blank lines, which are preserved to maintain file structure.
+ */
+export interface GenericParseResultSyntheticNode extends Omit<GenericParseResult, 'synthetic' | 'type'> {
+    /** The synthetic node type (e.g., 'comment', 'blankline') */
+    type: SyntheticNodeType;
+    /** Always true to distinguish synthetic nodes from real Beancount directives */
+    synthetic: true;
 }
 /**
- * Generic parse result for entries that include a date field.
+ * Generic parse result for directives that include a date field.
  * Extends the base result with date and metadata properties.
  */
 export interface GenericParseResultWithDate extends GenericParseResult {
@@ -34,7 +41,7 @@ export interface GenericParseResultWithDate extends GenericParseResult {
     };
 }
 /**
- * Generic parse result specifically for transaction entries.
+ * Generic parse result specifically for transaction directives.
  * Extends the dated result with transaction-specific fields like body lines and flags.
  */
 export interface GenericParseResultTransaction extends Omit<GenericParseResultWithDate, 'metadata'> {
@@ -51,16 +58,16 @@ export interface GenericParseResultTransaction extends Omit<GenericParseResultWi
     };
 }
 /**
- * Performs generic parsing on an unparsed entry to extract common fields.
+ * Performs generic parsing on a source fragment to extract common fields.
  *
  * This function:
- * - Detects if the entry has a date (YYYY-MM-DD format)
- * - Identifies the entry type
+ * - Detects if the directive has a date (YYYY-MM-DD format)
+ * - Identifies the directive type
  * - Extracts header content and comments
  * - Handles transaction-specific parsing (flags, body lines)
- * - Parses metadata for dated entries
+ * - Parses metadata for dated directives
  *
- * @param unparsedEntry - Array of string tokens representing a single entry
- * @returns A generic parse result object appropriate for the entry type
+ * @param sourceFragment - Array of strings that should be parsed to a single node
+ * @returns A generic parse result object appropriate for the node type
  */
-export declare const genericParse: (unparsedEntry: string[]) => GenericParseResult | GenericParseResultTransaction | GenericParseResultWithDate | GenericParseResultFakeEntry;
+export declare const genericParse: (sourceFragment: string[]) => GenericParseResult | GenericParseResultTransaction | GenericParseResultWithDate | GenericParseResultSyntheticNode;

package/build/src/genericParse.mjs

@@ -1,68 +1,68 @@
-import { DATED_ENTRY_TYPES, NON_DATED_ENTRY_TYPES } from './entryTypes.mjs';
+import { DATED_DIRECTIVE_TYPES, NON_DATED_DIRECTIVE_TYPES, } from './directiveTypes.mjs';
 import { parseMetadata } from './utils/parseMetadata.mjs';
 /**
- * Compiles a regex pattern that validates both date format AND entry type.
+ * Compiles a regex pattern that validates both date format AND directive type.
  *
  * The generated pattern matches lines starting with:
  * - Date in YYYY-MM-DD format
  * - Followed by one or more whitespace characters
  * - Followed by either:
- *   - A valid dated entry type keyword from {@link DATED_ENTRY_TYPES}
+ *   - A valid dated node type keyword from {@link DATED_DIRECTIVE_TYPES}
  *   - A transaction flag (* or !)
  *   - The transaction alias 'txn'
  * - Followed by a word boundary to prevent partial matches
  *
- * This ensures that only valid Beancount directives with correct entry types
- * are recognized. Invalid entry types will be treated as comments.
+ * This ensures that only valid Beancount directives with correct node types
+ * are recognized. Invalid directive types will be treated as comments.
  *
  * Pattern: `^YYYY-MM-DD\s+(validType|[*!]|txn)\b`
  *
- * @returns A RegExp that validates dated entry lines
+ * @returns A RegExp that validates dated node lines
  */
-function compileEntryRegex() {
-    // Join all non dated entry types with | for regex alternation
-    const nonDatedEntryPattern = NON_DATED_ENTRY_TYPES.join('|');
-    // Join all dated entry types with | for regex alternation
-    const datedEntryTypePattern = [
-        ...DATED_ENTRY_TYPES,
+function compileDirectivePattern() {
+    // Join all non dated directive types with | for regex alternation
+    const nonDatedDirectivesPattern = NON_DATED_DIRECTIVE_TYPES.join('|');
+    // Join all dated directive types with | for regex alternation
+    const datedDirectivesTypePattern = [
+        ...DATED_DIRECTIVE_TYPES,
         'txn',
         '[^ ]' /* flag */,
     ].join('|');
     const datePattern = `\\d{4}-\\d{2}-\\d{2}`;
-    const datedEntryPattern = `${datePattern} +(?:${datedEntryTypePattern})`;
-    const pattern = `^(?:${nonDatedEntryPattern})|(?:^${datedEntryPattern}) `;
+    const datedDirectivesPattern = `${datePattern} +(?:${datedDirectivesTypePattern})`;
+    const pattern = `^(?:${nonDatedDirectivesPattern})|(?:^${datedDirectivesPattern}) `;
     return new RegExp(pattern);
 }
 /**
- * Regex pattern to identify Beancount entries that start with a date.
- * Generated from {@link NON_DATED_ENTRY_TYPES} and {@link DATED_ENTRY_TYPES} to ensure validation of entry types.
+ * Regex pattern to identify Beancount directives that start with a date.
+ * Generated from {@link NON_DATED_DIRECTIVE_TYPES} and {@link DATED_DIRECTIVE_TYPES} to ensure validation of directive types.
  */
-const beanCountEntryRegex = compileEntryRegex();
+const beanCountDirectiveRegex = compileDirectivePattern();
 /**
- * Performs generic parsing on an unparsed entry to extract common fields.
+ * Performs generic parsing on a source fragment to extract common fields.
  *
  * This function:
- * - Detects if the entry has a date (YYYY-MM-DD format)
- * - Identifies the entry type
+ * - Detects if the directive has a date (YYYY-MM-DD format)
+ * - Identifies the directive type
  * - Extracts header content and comments
  * - Handles transaction-specific parsing (flags, body lines)
- * - Parses metadata for dated entries
+ * - Parses metadata for dated directives
  *
- * @param unparsedEntry - Array of string tokens representing a single entry
- * @returns A generic parse result object appropriate for the entry type
+ * @param sourceFragment - Array of strings that should be parsed to a single node
+ * @returns A generic parse result object appropriate for the node type
  */
-export const genericParse = (unparsedEntry) => {
-    const [firstLine, ...rest] = unparsedEntry;
+export const genericParse = (sourceFragment) => {
+    const [firstLine, ...rest] = sourceFragment;
     if (firstLine.trim() === '') {
-        return { type: 'blankline', header: '', props: {}, fake: true };
+        return { type: 'blankline', header: '', props: {}, synthetic: true };
     }
-    if (!beanCountEntryRegex.test(firstLine)) {
-        // not a valid beancount entry, return it as a comment
+    if (!beanCountDirectiveRegex.test(firstLine)) {
+        // not a valid beancount directive, return it as a comment
         return {
             type: 'comment',
-            header: unparsedEntry.join('\n'),
+            header: sourceFragment.join('\n'),
             props: {},
-            fake: true,
+            synthetic: true,
         };
     }
     const splitFirstLine = firstLine.split(' ');

package/build/src/main.d.mts

@@ -3,7 +3,7 @@
  *
  * @remarks
  * The primary function you'll use is {@link parse}, which parses a complete Beancount file
- * and returns a {@link ParseResult} containing all parsed entries.
+ * and returns a {@link ParseResult} containing parsed nodes.
  *
  * @example
  * ```typescript
@@ -17,43 +17,42 @@
  * `
  *
  * const result = parse(beancountContent)
- * console.log(result.entries) // Array of parsed Entry objects
+ * console.log(result.nodes) // Array of parsed Node objects
  * ```
  *
  * @module
  */
-export { parse, parseEntry } from './parse.mjs';
-export { deserializeEntry, deserializeEntryFromString, deserializeEntries, deserializeEntriesFromString, } from './deserialize.mjs';
+export { parse, parseSourceFragment } from './parse.mjs';
+export { deserializeNode, deserializeNodeFromString, deserializeNodes, deserializeNodesFromString, } from './deserialize.mjs';
 export { parseFile, type ParseFileOptions, type FileSystemHelpers, } from './parseFile.mjs';
 export type { GenericParseResult, GenericParseResultWithDate, GenericParseResultTransaction, } from './genericParse.mjs';
 export type { Metadata } from './utils/parseMetadata.mjs';
 export { ParseResult, type ParseResultObj, type FormatOptions, type CalculateCurrencyColumnOptions, } from './classes/ParseResult.mjs';
-export { Entry, assertEntryConstructor } from './classes/Entry.mjs';
-export { DateEntry } from './classes/DateEntry.mjs';
-export type { BeancountDateEntryType } from './classes/DateEntry.mjs';
+export { Node, assertNodeConstructor } from './classes/Node.mjs';
+export { DatedNode } from './classes/DatedNode.mjs';
 export { Value } from './classes/Value.mjs';
 export type { ValueType } from './classes/Value.mjs';
-export { Balance } from './classes/entryTypes/Balance.mjs';
-export { Blankline } from './classes/entryTypes/Blankline.mjs';
-export { Close } from './classes/entryTypes/Close.mjs';
-export { Comment } from './classes/entryTypes/Comment.mjs';
-export { Commodity } from './classes/entryTypes/Commodity.mjs';
-export { Custom } from './classes/entryTypes/Custom.mjs';
-export { Document } from './classes/entryTypes/Document.mjs';
-export { Event } from './classes/entryTypes/Event.mjs';
-export { Include } from './classes/entryTypes/Include.mjs';
-export { Note } from './classes/entryTypes/Note.mjs';
-export { Open } from './classes/entryTypes/Open.mjs';
-export { Option } from './classes/entryTypes/Option.mjs';
-export { Pad } from './classes/entryTypes/Pad.mjs';
-export { Plugin } from './classes/entryTypes/Plugin.mjs';
-export { Poptag } from './classes/entryTypes/Poptag.mjs';
-export { Price } from './classes/entryTypes/Price.mjs';
-export { Pushtag } from './classes/entryTypes/Pushtag.mjs';
-export { Query } from './classes/entryTypes/Query.mjs';
-export { Transaction, type PostingComment, } from './classes/entryTypes/Transaction/index.mjs';
-export { Posting } from './classes/entryTypes/Transaction/Posting.mjs';
-export { Tag } from './classes/entryTypes/Transaction/Tag.mjs';
-export type { BeancountEntryType, EntryType, FakeEntryType, BeancountDatedEntryType, BeancountNonDatedEntryType, } from './entryTypeToClass.mjs';
-export { beancountEntryToClass, entryTypeToClass } from './entryTypeToClass.mjs';
-export { DATED_ENTRY_TYPES, NON_DATED_ENTRY_TYPES } from './entryTypes.mjs';
+export { Balance } from './classes/nodes/Balance.mjs';
+export { Blankline } from './classes/nodes/Blankline.mjs';
+export { Close } from './classes/nodes/Close.mjs';
+export { Comment } from './classes/nodes/Comment.mjs';
+export { Commodity } from './classes/nodes/Commodity.mjs';
+export { Custom } from './classes/nodes/Custom.mjs';
+export { Document } from './classes/nodes/Document.mjs';
+export { Event } from './classes/nodes/Event.mjs';
+export { Include } from './classes/nodes/Include.mjs';
+export { Note } from './classes/nodes/Note.mjs';
+export { Open } from './classes/nodes/Open.mjs';
+export { Option } from './classes/nodes/Option.mjs';
+export { Pad } from './classes/nodes/Pad.mjs';
+export { Plugin } from './classes/nodes/Plugin.mjs';
+export { Poptag } from './classes/nodes/Poptag.mjs';
+export { Price } from './classes/nodes/Price.mjs';
+export { Pushtag } from './classes/nodes/Pushtag.mjs';
+export { Query } from './classes/nodes/Query.mjs';
+export { Transaction, type PostingComment, } from './classes/nodes/Transaction/index.mjs';
+export { Posting } from './classes/nodes/Transaction/Posting.mjs';
+export { Tag } from './classes/nodes/Transaction/Tag.mjs';
+export type { BeancountDirectiveNodeType, NodeType, SyntheticNodeType, DatedDirectiveNodeType, NonDatedDirectiveNodeType, } from './nodeTypeToClass.mjs';
+export { beancountDirectiveNodeTypeToClass, nodeTypeToClass, } from './nodeTypeToClass.mjs';
+export { DATED_DIRECTIVE_TYPES, NON_DATED_DIRECTIVE_TYPES, } from './directiveTypes.mjs';