legal-markdown-js 0.1.0

package/dist/constants/index.d.ts

@@ -0,0 +1,229 @@
+/**
+ * @fileoverview Constants and Configuration for Legal Markdown Processing
+ *
+ * This module contains all the constants, regular expressions, and configuration
+ * values used throughout the Legal Markdown processing system. It provides
+ * centralized definitions for patterns, options, and supported formats.
+ *
+ * Features:
+ * - Default processing options and configurations
+ * - Regular expression patterns for parsing different markup elements
+ * - Supported file formats and extensions
+ * - Error codes for consistent error handling
+ * - Constants for import, clause, and reference processing
+ * - Type-safe constant definitions with 'as const' assertions
+ *
+ * @example
+ * ```typescript
+ * import { DEFAULT_OPTIONS, HEADER_PATTERNS, ERROR_CODES } from './constants';
+ *
+ * // Use default options
+ * const options = { ...DEFAULT_OPTIONS, debug: true };
+ *
+ * // Use header patterns
+ * const headerMatch = content.match(HEADER_PATTERNS.TRADITIONAL);
+ *
+ * // Use error codes
+ * throw new Error(ERROR_CODES.YAML_PARSING_ERROR);
+ * ```
+ */
+/**
+ * Default options for Legal Markdown processing
+ *
+ * @constant {Object} DEFAULT_OPTIONS
+ * @example
+ * ```typescript
+ * import { DEFAULT_OPTIONS } from './constants';
+ *
+ * // Use default options
+ * const options = { ...DEFAULT_OPTIONS, debug: true };
+ *
+ * // Override specific options
+ * const customOptions = {
+ *   ...DEFAULT_OPTIONS,
+ *   yamlOnly: true,
+ *   exportMetadata: true,
+ *   exportFormat: 'json' as const
+ * };
+ * ```
+ */
+export declare const DEFAULT_OPTIONS: {
+    /** Process only YAML frontmatter, skip content processing */
+    yamlOnly: boolean;
+    /** Skip processing of header structures */
+    noHeaders: boolean;
+    /** Skip processing of optional clauses */
+    noClauses: boolean;
+    /** Skip processing of cross-references */
+    noReferences: boolean;
+    /** Skip processing of import statements */
+    noImports: boolean;
+    /** Export metadata to external files */
+    exportMetadata: boolean;
+    /** Format for metadata export */
+    exportFormat: "yaml";
+    /** Enable debug logging */
+    debug: boolean;
+    /** Throw errors on YAML parsing failures */
+    throwOnYamlError: boolean;
+};
+/**
+ * Regular expression patterns for parsing header structures
+ *
+ * @constant {Object} HEADER_PATTERNS
+ * @example
+ * ```typescript
+ * import { HEADER_PATTERNS } from './constants';
+ *
+ * // Match traditional headers: l. Section, ll. Subsection
+ * const traditionalHeaders = content.match(HEADER_PATTERNS.TRADITIONAL);
+ *
+ * // Match alternative headers: l1. Section, l2. Subsection
+ * const alternativeHeaders = content.match(HEADER_PATTERNS.ALTERNATIVE);
+ * ```
+ */
+export declare const HEADER_PATTERNS: {
+    /** Traditional header pattern: l. Section, ll. Subsection, etc. */
+    readonly TRADITIONAL: RegExp;
+    /** Alternative header pattern: l1. Section, l2. Subsection, etc. */
+    readonly ALTERNATIVE: RegExp;
+};
+/**
+ * Regular expression patterns for parsing import statements
+ *
+ * @constant {Object} IMPORT_PATTERNS
+ * @example
+ * ```typescript
+ * import { IMPORT_PATTERNS } from './constants';
+ *
+ * // Match partial imports: [[filename]]
+ * const partialImports = content.match(IMPORT_PATTERNS.PARTIAL);
+ *
+ * // Match full file imports: @import filename
+ * const fullImports = content.match(IMPORT_PATTERNS.FULL_FILE);
+ * ```
+ */
+export declare const IMPORT_PATTERNS: {
+    /** Partial import pattern: [[filename]] */
+    readonly PARTIAL: RegExp;
+    /** Full file import pattern: @import filename */
+    readonly FULL_FILE: RegExp;
+};
+/**
+ * Regular expression patterns for parsing optional and conditional clauses
+ *
+ * @constant {Object} CLAUSE_PATTERNS
+ * @example
+ * ```typescript
+ * import { CLAUSE_PATTERNS } from './constants';
+ *
+ * // Match optional clauses: {{field.name}}
+ * const optionalClauses = content.match(CLAUSE_PATTERNS.OPTIONAL);
+ *
+ * // Match conditional clauses: {{#if condition}}content{{/if}}
+ * const conditionalClauses = content.match(CLAUSE_PATTERNS.CONDITIONAL);
+ * ```
+ */
+export declare const CLAUSE_PATTERNS: {
+    /** Optional clause pattern: {{field.name}} */
+    readonly OPTIONAL: RegExp;
+    /** Conditional clause pattern: {{#if condition}}content{{/if}} */
+    readonly CONDITIONAL: RegExp;
+};
+/**
+ * Regular expression patterns for parsing cross-references
+ *
+ * @constant {Object} REFERENCE_PATTERNS
+ * @example
+ * ```typescript
+ * import { REFERENCE_PATTERNS } from './constants';
+ *
+ * // Match cross-references: [[reference]]
+ * const crossRefs = content.match(REFERENCE_PATTERNS.CROSS_REF);
+ *
+ * // Match numbered references: [1], [2], etc.
+ * const numberedRefs = content.match(REFERENCE_PATTERNS.NUMBERED_REF);
+ * ```
+ */
+export declare const REFERENCE_PATTERNS: {
+    /** Cross-reference pattern: [[reference]] */
+    readonly CROSS_REF: RegExp;
+    /** Numbered reference pattern: [1], [2], etc. */
+    readonly NUMBERED_REF: RegExp;
+};
+/**
+ * Supported file formats for input and export operations
+ *
+ * @constant {Object} SUPPORTED_FORMATS
+ * @example
+ * ```typescript
+ * import { SUPPORTED_FORMATS } from './constants';
+ *
+ * // Check if format is supported for export
+ * const isExportSupported = SUPPORTED_FORMATS.EXPORT.includes('yaml');
+ *
+ * // Check if input format is supported
+ * const isInputSupported = SUPPORTED_FORMATS.INPUT.includes('md');
+ * ```
+ */
+export declare const SUPPORTED_FORMATS: {
+    /** Supported export formats */
+    readonly EXPORT: readonly ["yaml", "json"];
+    /** Supported input formats */
+    readonly INPUT: readonly ["md", "markdown"];
+};
+/**
+ * File extensions for different document types
+ *
+ * @constant {Object} FILE_EXTENSIONS
+ * @example
+ * ```typescript
+ * import { FILE_EXTENSIONS } from './constants';
+ *
+ * // Check if file is markdown
+ * const isMarkdown = FILE_EXTENSIONS.MARKDOWN.includes(path.extname(filename));
+ *
+ * // Check if file is YAML
+ * const isYaml = FILE_EXTENSIONS.YAML.includes(path.extname(filename));
+ * ```
+ */
+export declare const FILE_EXTENSIONS: {
+    /** Markdown file extensions */
+    readonly MARKDOWN: readonly [".md", ".markdown"];
+    /** YAML file extensions */
+    readonly YAML: readonly [".yml", ".yaml"];
+    /** JSON file extensions */
+    readonly JSON: readonly [".json"];
+};
+/**
+ * Error codes for consistent error handling throughout the system
+ *
+ * @constant {Object} ERROR_CODES
+ * @example
+ * ```typescript
+ * import { ERROR_CODES } from './constants';
+ *
+ * // Use error codes in custom errors
+ * throw new Error(ERROR_CODES.YAML_PARSING_ERROR);
+ *
+ * // Check error codes in error handling
+ * if (error.code === ERROR_CODES.FILE_NOT_FOUND) {
+ *   // Handle file not found error
+ * }
+ * ```
+ */
+export declare const ERROR_CODES: {
+    /** YAML parsing error code */
+    readonly YAML_PARSING_ERROR: "YAML_PARSING_ERROR";
+    /** File not found error code */
+    readonly FILE_NOT_FOUND: "FILE_NOT_FOUND";
+    /** Import processing error code */
+    readonly IMPORT_PROCESSING_ERROR: "IMPORT_PROCESSING_ERROR";
+    /** Metadata export error code */
+    readonly METADATA_EXPORT_ERROR: "METADATA_EXPORT_ERROR";
+    /** Validation error code */
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    /** General processing error code */
+    readonly PROCESSING_ERROR: "PROCESSING_ERROR";
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,eAAe;IAC1B,6DAA6D;;IAE7D,2CAA2C;;IAE3C,0CAA0C;;IAE1C,0CAA0C;;IAE1C,2CAA2C;;IAE3C,wCAAwC;;IAExC,iCAAiC;;IAEjC,2BAA2B;;IAE3B,4CAA4C;;CAE7C,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;IAC1B,mEAAmE;;IAEnE,oEAAoE;;CAE5D,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;IAC1B,2CAA2C;;IAE3C,iDAAiD;;CAEzC,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;IAC1B,8CAA8C;;IAE9C,kEAAkE;;CAE1D,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB;IAC7B,6CAA6C;;IAE7C,iDAAiD;;CAEzC,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB;IAC5B,+BAA+B;;IAE/B,8BAA8B;;CAEtB,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;IAC1B,+BAA+B;;IAE/B,2BAA2B;;IAE3B,2BAA2B;;CAEnB,CAAC;AAEX;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW;IACtB,8BAA8B;;IAE9B,gCAAgC;;IAEhC,mCAAmC;;IAEnC,iCAAiC;;IAEjC,4BAA4B;;IAE5B,oCAAoC;;CAE5B,CAAC"}

package/dist/constants/index.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * @fileoverview Constants and Configuration for Legal Markdown Processing
+ *
+ * This module contains all the constants, regular expressions, and configuration
+ * values used throughout the Legal Markdown processing system. It provides
+ * centralized definitions for patterns, options, and supported formats.
+ *
+ * Features:
+ * - Default processing options and configurations
+ * - Regular expression patterns for parsing different markup elements
+ * - Supported file formats and extensions
+ * - Error codes for consistent error handling
+ * - Constants for import, clause, and reference processing
+ * - Type-safe constant definitions with 'as const' assertions
+ *
+ * @example
+ * ```typescript
+ * import { DEFAULT_OPTIONS, HEADER_PATTERNS, ERROR_CODES } from './constants';
+ *
+ * // Use default options
+ * const options = { ...DEFAULT_OPTIONS, debug: true };
+ *
+ * // Use header patterns
+ * const headerMatch = content.match(HEADER_PATTERNS.TRADITIONAL);
+ *
+ * // Use error codes
+ * throw new Error(ERROR_CODES.YAML_PARSING_ERROR);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_CODES = exports.FILE_EXTENSIONS = exports.SUPPORTED_FORMATS = exports.REFERENCE_PATTERNS = exports.CLAUSE_PATTERNS = exports.IMPORT_PATTERNS = exports.HEADER_PATTERNS = exports.DEFAULT_OPTIONS = void 0;
+/**
+ * Default options for Legal Markdown processing
+ *
+ * @constant {Object} DEFAULT_OPTIONS
+ * @example
+ * ```typescript
+ * import { DEFAULT_OPTIONS } from './constants';
+ *
+ * // Use default options
+ * const options = { ...DEFAULT_OPTIONS, debug: true };
+ *
+ * // Override specific options
+ * const customOptions = {
+ *   ...DEFAULT_OPTIONS,
+ *   yamlOnly: true,
+ *   exportMetadata: true,
+ *   exportFormat: 'json' as const
+ * };
+ * ```
+ */
+exports.DEFAULT_OPTIONS = {
+    /** Process only YAML frontmatter, skip content processing */
+    yamlOnly: false,
+    /** Skip processing of header structures */
+    noHeaders: false,
+    /** Skip processing of optional clauses */
+    noClauses: false,
+    /** Skip processing of cross-references */
+    noReferences: false,
+    /** Skip processing of import statements */
+    noImports: false,
+    /** Export metadata to external files */
+    exportMetadata: false,
+    /** Format for metadata export */
+    exportFormat: 'yaml',
+    /** Enable debug logging */
+    debug: false,
+    /** Throw errors on YAML parsing failures */
+    throwOnYamlError: false,
+};
+/**
+ * Regular expression patterns for parsing header structures
+ *
+ * @constant {Object} HEADER_PATTERNS
+ * @example
+ * ```typescript
+ * import { HEADER_PATTERNS } from './constants';
+ *
+ * // Match traditional headers: l. Section, ll. Subsection
+ * const traditionalHeaders = content.match(HEADER_PATTERNS.TRADITIONAL);
+ *
+ * // Match alternative headers: l1. Section, l2. Subsection
+ * const alternativeHeaders = content.match(HEADER_PATTERNS.ALTERNATIVE);
+ * ```
+ */
+exports.HEADER_PATTERNS = {
+    /** Traditional header pattern: l. Section, ll. Subsection, etc. */
+    TRADITIONAL: /^(l+)\.\s+(.*?)$/gm,
+    /** Alternative header pattern: l1. Section, l2. Subsection, etc. */
+    ALTERNATIVE: /^l(\d+)\.\s+(.*?)$/gm,
+};
+/**
+ * Regular expression patterns for parsing import statements
+ *
+ * @constant {Object} IMPORT_PATTERNS
+ * @example
+ * ```typescript
+ * import { IMPORT_PATTERNS } from './constants';
+ *
+ * // Match partial imports: [[filename]]
+ * const partialImports = content.match(IMPORT_PATTERNS.PARTIAL);
+ *
+ * // Match full file imports: @import filename
+ * const fullImports = content.match(IMPORT_PATTERNS.FULL_FILE);
+ * ```
+ */
+exports.IMPORT_PATTERNS = {
+    /** Partial import pattern: [[filename]] */
+    PARTIAL: /\[\[(.*?)\]\]/g,
+    /** Full file import pattern: @import filename */
+    FULL_FILE: /^@import\s+(.+)$/gm,
+};
+/**
+ * Regular expression patterns for parsing optional and conditional clauses
+ *
+ * @constant {Object} CLAUSE_PATTERNS
+ * @example
+ * ```typescript
+ * import { CLAUSE_PATTERNS } from './constants';
+ *
+ * // Match optional clauses: {{field.name}}
+ * const optionalClauses = content.match(CLAUSE_PATTERNS.OPTIONAL);
+ *
+ * // Match conditional clauses: {{#if condition}}content{{/if}}
+ * const conditionalClauses = content.match(CLAUSE_PATTERNS.CONDITIONAL);
+ * ```
+ */
+exports.CLAUSE_PATTERNS = {
+    /** Optional clause pattern: {{field.name}} */
+    OPTIONAL: /\{\{\s*([^}]+)\s*\}\}/g,
+    /** Conditional clause pattern: {{#if condition}}content{{/if}} */
+    CONDITIONAL: /\{\{\s*#if\s+([^}]+)\s*\}\}([\s\S]*?)\{\{\s*\/if\s*\}\}/g,
+};
+/**
+ * Regular expression patterns for parsing cross-references
+ *
+ * @constant {Object} REFERENCE_PATTERNS
+ * @example
+ * ```typescript
+ * import { REFERENCE_PATTERNS } from './constants';
+ *
+ * // Match cross-references: [[reference]]
+ * const crossRefs = content.match(REFERENCE_PATTERNS.CROSS_REF);
+ *
+ * // Match numbered references: [1], [2], etc.
+ * const numberedRefs = content.match(REFERENCE_PATTERNS.NUMBERED_REF);
+ * ```
+ */
+exports.REFERENCE_PATTERNS = {
+    /** Cross-reference pattern: [[reference]] */
+    CROSS_REF: /\[\[([^\]]+)\]\]/g,
+    /** Numbered reference pattern: [1], [2], etc. */
+    NUMBERED_REF: /\[(\d+)\]/g,
+};
+/**
+ * Supported file formats for input and export operations
+ *
+ * @constant {Object} SUPPORTED_FORMATS
+ * @example
+ * ```typescript
+ * import { SUPPORTED_FORMATS } from './constants';
+ *
+ * // Check if format is supported for export
+ * const isExportSupported = SUPPORTED_FORMATS.EXPORT.includes('yaml');
+ *
+ * // Check if input format is supported
+ * const isInputSupported = SUPPORTED_FORMATS.INPUT.includes('md');
+ * ```
+ */
+exports.SUPPORTED_FORMATS = {
+    /** Supported export formats */
+    EXPORT: ['yaml', 'json'],
+    /** Supported input formats */
+    INPUT: ['md', 'markdown'],
+};
+/**
+ * File extensions for different document types
+ *
+ * @constant {Object} FILE_EXTENSIONS
+ * @example
+ * ```typescript
+ * import { FILE_EXTENSIONS } from './constants';
+ *
+ * // Check if file is markdown
+ * const isMarkdown = FILE_EXTENSIONS.MARKDOWN.includes(path.extname(filename));
+ *
+ * // Check if file is YAML
+ * const isYaml = FILE_EXTENSIONS.YAML.includes(path.extname(filename));
+ * ```
+ */
+exports.FILE_EXTENSIONS = {
+    /** Markdown file extensions */
+    MARKDOWN: ['.md', '.markdown'],
+    /** YAML file extensions */
+    YAML: ['.yml', '.yaml'],
+    /** JSON file extensions */
+    JSON: ['.json'],
+};
+/**
+ * Error codes for consistent error handling throughout the system
+ *
+ * @constant {Object} ERROR_CODES
+ * @example
+ * ```typescript
+ * import { ERROR_CODES } from './constants';
+ *
+ * // Use error codes in custom errors
+ * throw new Error(ERROR_CODES.YAML_PARSING_ERROR);
+ *
+ * // Check error codes in error handling
+ * if (error.code === ERROR_CODES.FILE_NOT_FOUND) {
+ *   // Handle file not found error
+ * }
+ * ```
+ */
+exports.ERROR_CODES = {
+    /** YAML parsing error code */
+    YAML_PARSING_ERROR: 'YAML_PARSING_ERROR',
+    /** File not found error code */
+    FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+    /** Import processing error code */
+    IMPORT_PROCESSING_ERROR: 'IMPORT_PROCESSING_ERROR',
+    /** Metadata export error code */
+    METADATA_EXPORT_ERROR: 'METADATA_EXPORT_ERROR',
+    /** Validation error code */
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    /** General processing error code */
+    PROCESSING_ERROR: 'PROCESSING_ERROR',
+};
+//# sourceMappingURL=index.js.map

package/dist/constants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;;;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACU,QAAA,eAAe,GAAG;IAC7B,6DAA6D;IAC7D,QAAQ,EAAE,KAAK;IACf,2CAA2C;IAC3C,SAAS,EAAE,KAAK;IAChB,0CAA0C;IAC1C,SAAS,EAAE,KAAK;IAChB,0CAA0C;IAC1C,YAAY,EAAE,KAAK;IACnB,2CAA2C;IAC3C,SAAS,EAAE,KAAK;IAChB,wCAAwC;IACxC,cAAc,EAAE,KAAK;IACrB,iCAAiC;IACjC,YAAY,EAAE,MAAe;IAC7B,2BAA2B;IAC3B,KAAK,EAAE,KAAK;IACZ,4CAA4C;IAC5C,gBAAgB,EAAE,KAAK;CACxB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACU,QAAA,eAAe,GAAG;IAC7B,mEAAmE;IACnE,WAAW,EAAE,oBAAoB;IACjC,oEAAoE;IACpE,WAAW,EAAE,sBAAsB;CAC3B,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACU,QAAA,eAAe,GAAG;IAC7B,2CAA2C;IAC3C,OAAO,EAAE,gBAAgB;IACzB,iDAAiD;IACjD,SAAS,EAAE,oBAAoB;CACvB,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACU,QAAA,eAAe,GAAG;IAC7B,8CAA8C;IAC9C,QAAQ,EAAE,wBAAwB;IAClC,kEAAkE;IAClE,WAAW,EAAE,0DAA0D;CAC/D,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACU,QAAA,kBAAkB,GAAG;IAChC,6CAA6C;IAC7C,SAAS,EAAE,mBAAmB;IAC9B,iDAAiD;IACjD,YAAY,EAAE,YAAY;CAClB,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACU,QAAA,iBAAiB,GAAG;IAC/B,+BAA+B;IAC/B,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAU;IACjC,8BAA8B;IAC9B,KAAK,EAAE,CAAC,IAAI,EAAE,UAAU,CAAU;CAC1B,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACU,QAAA,eAAe,GAAG;IAC7B,+BAA+B;IAC/B,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;IAC9B,2BAA2B;IAC3B,IAAI,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;IACvB,2BAA2B;IAC3B,IAAI,EAAE,CAAC,OAAO,CAAC;CACP,CAAC;AAEX;;;;;;;;;;;;;;;;GAgBG;AACU,QAAA,WAAW,GAAG;IACzB,8BAA8B;IAC9B,kBAAkB,EAAE,oBAAoB;IACxC,gCAAgC;IAChC,cAAc,EAAE,gBAAgB;IAChC,mCAAmC;IACnC,uBAAuB,EAAE,yBAAyB;IAClD,iCAAiC;IACjC,qBAAqB,EAAE,uBAAuB;IAC9C,4BAA4B;IAC5B,gBAAgB,EAAE,kBAAkB;IACpC,oCAAoC;IACpC,gBAAgB,EAAE,kBAAkB;CAC5B,CAAC"}

package/dist/core/exporters/metadata-exporter.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @fileoverview Metadata Export System for Legal Markdown Documents
+ *
+ * This module provides functionality for exporting document metadata to external
+ * files in various formats. It supports YAML and JSON export formats with
+ * configurable output paths and metadata filtering.
+ *
+ * Features:
+ * - Metadata export to YAML and JSON formats
+ * - Configurable output paths and filenames
+ * - Metadata filtering and processing
+ * - Internal metadata key removal
+ * - Directory creation for output files
+ * - Error handling and logging
+ * - Support for custom export configurations
+ *
+ * @example
+ * ```typescript
+ * import { exportMetadata } from './metadata-exporter';
+ *
+ * // Export metadata to YAML
+ * const result = exportMetadata(metadata, 'yaml', './output');
+ * console.log('Exported files:', result.exportedFiles);
+ *
+ * // Export with custom configuration
+ * const metadata = {
+ *   title: 'Legal Agreement',
+ *   'meta-yaml-output': 'custom-metadata.yaml',
+ *   'meta-json-output': 'custom-metadata.json'
+ * };
+ * const result = exportMetadata(metadata);
+ * ```
+ */
+import { MetadataExportResult } from '@types';
+/**
+ * Exports document metadata to external files
+ *
+ * Processes document metadata and exports it to specified formats (YAML/JSON)
+ * with support for custom output paths and metadata filtering. Handles directory
+ * creation and provides comprehensive error handling.
+ *
+ * @async
+ * @function exportMetadata
+ * @param {Record<string, any>} metadata - Document metadata to export
+ * @param {'yaml' | 'json'} [format] - Export format (yaml or json)
+ * @param {string} [outputPath] - Optional path for export files
+ * @returns {MetadataExportResult} Result object with list of exported files
+ * @example
+ * ```typescript
+ * import { exportMetadata } from './metadata-exporter';
+ *
+ * // Basic metadata export
+ * const metadata = {
+ *   title: 'Service Agreement',
+ *   author: 'Legal Team',
+ *   version: '1.0',
+ *   date: '2023-01-01'
+ * };
+ *
+ * const result = exportMetadata(metadata, 'yaml', './output');
+ * console.log('Exported to:', result.exportedFiles);
+ *
+ * // Export with custom filenames
+ * const customMetadata = {
+ *   title: 'Contract',
+ *   'meta-yaml-output': 'contract-metadata.yaml',
+ *   'meta-json-output': 'contract-metadata.json',
+ *   'meta-output-path': './custom-output'
+ * };
+ *
+ * const customResult = exportMetadata(customMetadata);
+ * ```
+ */
+export declare function exportMetadata(metadata: Record<string, any>, format?: 'yaml' | 'json', outputPath?: string): MetadataExportResult;
+/**
+ * Filters metadata based on export configuration
+ *
+ * Processes metadata to remove internal configuration keys and applies filtering
+ * rules based on export settings. This ensures that only relevant metadata is
+ * included in the exported files.
+ *
+ * @function filterMetadataForExport
+ * @param {Record<string, any>} metadata - Complete metadata object to filter
+ * @returns {Record<string, any>} Filtered metadata object suitable for export
+ * @example
+ * ```typescript
+ * import { filterMetadataForExport } from './metadata-exporter';
+ *
+ * const metadata = {
+ *   title: 'Legal Agreement',
+ *   author: 'Legal Team',
+ *   'meta-yaml-output': 'output.yaml',
+ *   'meta-json-output': 'output.json',
+ *   'meta-output-path': './exports',
+ *   'meta-include-original': false
+ * };
+ *
+ * const filtered = filterMetadataForExport(metadata);
+ * // Result: { title: 'Legal Agreement', author: 'Legal Team' }
+ * // Internal meta-* keys are removed
+ * ```
+ */
+export declare function filterMetadataForExport(metadata: Record<string, any>): Record<string, any>;
+//# sourceMappingURL=metadata-exporter.d.ts.map

package/dist/core/exporters/metadata-exporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata-exporter.d.ts","sourceRoot":"","sources":["../../../src/core/exporters/metadata-exporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAKH,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7B,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EACxB,UAAU,CAAC,EAAE,MAAM,GAClB,oBAAoB,CAoDtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAgB1F"}