@n8n/ai-workflow-builder 0.31.2 → 0.32.1

package/dist/tools/best-practices/data-analysis.d.ts

@@ -0,0 +1,7 @@
+import type { BestPracticesDocument } from '../../types/best-practices';
+export declare class DataAnalysisBestPractices implements BestPracticesDocument {
+    readonly technique: "data_analysis";
+    readonly version = "1.0.0";
+    private readonly documentation;
+    getDocumentation(): string;
+}

package/dist/tools/best-practices/data-analysis.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataAnalysisBestPractices = void 0;
+const categorization_1 = require("../../types/categorization");
+class DataAnalysisBestPractices {
+    technique = categorization_1.WorkflowTechnique.DATA_ANALYSIS;
+    version = '1.0.0';
+    documentation = `# Best Practices: Data Analysis Workflows
+
+## Workflow Design
+
+Structure workflows following the Input → Transform → Output pattern. Use clear node naming (e.g., "Fetch Sales Data", "Calculate Averages", "IF High Variance?") to document the flow.
+
+Start with appropriate triggers:
+- Manual Trigger for on-demand analysis
+- Cron/Schedule Trigger for periodic analysis (daily/weekly reports)
+- Webhook Trigger for event-driven analysis
+
+Break complex workflows into modular sub-workflows using the Execute Workflow node for reusable components like "Outlier Detection" or "Data Preparation".
+
+CRITICAL: For large datasets, use Split In Batches node to process items in chunks (e.g., 100 at a time) to prevent memory issues. Always test with realistic data volumes.
+
+Example pattern:
+- Trigger → HTTP Request (fetch data) → Spreadsheet File (parse CSV) → Set (clean fields) → Filter (remove nulls) → Code (analyze) → HTML (format report) → Email (send results)
+
+## Data Preparation Strategy
+
+1. **Fetch Data**: Use dedicated integration nodes or HTTP Request for APIs. Import cURL commands directly to HTTP node for complex APIs.
+2. **Parse & Convert**: Convert to JSON using Spreadsheet File node for CSV/Excel. Enable "Convert types where required" on condition nodes.
+3. **Clean Data**: Use Set node with "Keep Only Set" enabled to drop unused fields. Filter node for removing null values or focusing on data subsets.
+4. **Merge/Enrich**: Use Merge node by key or index to combine multiple sources. Choose correct merge mode to avoid mismatched items.
+
+## Analysis Implementation
+
+Use Function node (not Function Item) when analysis needs all items as a whole (calculating totals, finding trends). Function Item operates per item only.
+
+For AI-powered analysis, filter irrelevant content first to minimize tokens. Batch data into single prompts when possible.
+
+Always pin data after external calls to test downstream logic without re-fetching. This saves API costs and speeds development.
+
+## Output & Integration
+
+Format results appropriately:
+- HTML/Markdown nodes for reports
+- Set node to prepare specific output fields (totalSales, anomalyCount)
+- Database nodes to store analysis history
+- Webhook Response for API-triggered workflows
+
+Use conditional branches (IF nodes) for post-analysis actions:
+- Create tasks if anomalies detected
+- Send alerts for critical thresholds
+- Avoid infinite loops by using proper conditions
+
+## Recommended Nodes
+
+### HTTP Request (n8n-nodes-base.httpRequest)
+
+**Purpose**: Fetch datasets from URLs or APIs
+
+**Use Cases**:
+- Pull data from REST APIs for analysis
+- Fetch CSV/JSON files from URLs
+- Query external data sources
+
+**Best Practices**:
+- Import cURL commands for complex requests
+- Use authentication credentials properly
+- Handle pagination for large datasets
+
+### Spreadsheet File (n8n-nodes-base.spreadsheetFile)
+
+**Purpose**: Parse CSV/Excel files into JSON items for processing
+
+**Use Cases**:
+- Import CSV data from file uploads
+- Process Excel spreadsheets
+- Convert tabular data to JSON
+
+**Best Practices**:
+- Specify correct file format
+- Handle header rows properly
+- Test with various file encodings
+
+### Set / Edit Fields (n8n-nodes-base.set)
+
+**Purpose**: Clean data, select relevant fields, rename columns, convert data types
+
+**Key Setting**: "Keep Only Set" - drops all fields not explicitly defined
+
+**Use Cases**:
+- Remove unused columns to reduce data size
+- Rename fields to standardized names
+- Convert data types (string to number)
+- Add calculated fields
+
+**Best Practices**:
+- Enable "Keep Only Set" to drop unused data
+- Always verify output structure
+- Use expressions for calculated fields
+
+### Filter (n8n-nodes-base.filter)
+
+**Purpose**: Remove unwanted items based on conditions
+
+**Use Cases**:
+- Remove null values
+- Filter outliers before analysis
+- Focus on specific data subsets
+
+**Best Practices**:
+- Filter early to reduce processing load
+- Use multiple conditions when needed
+- Document filter logic clearly
+
+### IF (n8n-nodes-base.if)
+
+**Purpose**: Branch workflow based on analysis results
+
+**Use Cases**:
+- Route anomalies vs normal data
+- Trigger alerts for threshold breaches
+- Create conditional outputs
+
+**Best Practices**:
+- Enable "Convert types where required" for comparisons
+- Use clear condition names
+- Handle both true and false branches
+
+### Code / Function (n8n-nodes-base.function)
+
+**Purpose**: Custom JavaScript for calculations, statistics, anomaly detection
+
+**Use Cases**:
+- Calculate statistical measures (mean, median, std dev)
+- Detect outliers and anomalies
+- Perform complex transformations
+- Implement custom algorithms
+
+**Best Practices**:
+- Use Function node (not Function Item) for whole-dataset operations
+- Return proper data structure: \`return items\`
+- Add comments to explain logic
+- Test with edge cases
+
+**Note**: Consider using the newer Code node (n8n-nodes-base.code) as Function node is deprecated.
+
+### Aggregate (n8n-nodes-base.aggregate)
+
+**Purpose**: Group items, gather values into arrays, count occurrences by category
+
+**Use Cases**:
+- Group sales by region
+- Count items by category
+- Calculate sums and averages per group
+
+**Best Practices**:
+- Choose appropriate aggregation function
+- Use grouping keys effectively
+- Simplifies statistical calculations
+
+### Split In Batches (n8n-nodes-base.splitInBatches)
+
+**Purpose**: Process large datasets in chunks to prevent memory overload
+
+**Use Cases**:
+- Handle datasets with 1000+ items
+- Process API results in batches
+- Prevent workflow timeouts
+
+**Best Practices**:
+- Set appropriate batch size (e.g., 100 items)
+- Test with realistic data volumes
+- Use loop logic properly
+
+### Merge (n8n-nodes-base.merge)
+
+**Purpose**: Combine data from multiple sources by key/index
+
+**Modes**:
+- Merge by Key: Join data like database operations
+- Merge by Index: Combine parallel data streams
+- Wait mode: Synchronize parallel branches
+
+**Use Cases**:
+- Join customer data with transaction data
+- Combine multiple API responses
+- Enrich data from multiple sources
+
+**Best Practices**:
+- Choose correct merge mode
+- Ensure matching keys exist
+- Handle missing data gracefully
+
+### Database Nodes
+
+**MySQL** (n8n-nodes-base.mySql):
+- Purpose: Query MySQL databases for analysis data
+- Use cases: Fetch historical data, store results
+
+**Postgres** (n8n-nodes-base.postgres):
+- Purpose: Query PostgreSQL databases
+- Use cases: Complex analytical queries, time-series data
+
+**MongoDB** (n8n-nodes-base.mongoDb):
+- Purpose: Query NoSQL document databases
+- Use cases: Unstructured data analysis, JSON documents
+
+**Best Practices**:
+- Use parameterized queries for security
+- Query source data efficiently with proper indexes
+- Store analysis results for historical tracking
+- Use appropriate data types
+
+### Google Sheets (n8n-nodes-base.googleSheets)
+
+**Purpose**: Read/write spreadsheet data
+
+**Use Cases**:
+- Import data for analysis
+- Append summary statistics
+- Build analysis logs
+- Share results with stakeholders
+
+**Best Practices**:
+- Use range specifications efficiently
+- Handle large sheets with batching
+- Consider API rate limits
+
+### AI Agent (@n8n/n8n-nodes-langchain.agent)
+
+**Purpose**: Leverage AI for text analysis, sentiment detection, complex pattern recognition
+
+**Use Cases**:
+- Sentiment analysis of customer feedback
+- Text classification
+- Extract insights from unstructured data
+- Natural language processing
+
+**Best Practices**:
+- Filter irrelevant content first to minimize tokens
+- Batch data into single prompts when possible
+- Use structured output for consistency
+- Consider API costs and latency
+
+### HTML (n8n-nodes-base.html)
+
+**Purpose**: Generate formatted reports with tables and styling
+
+**Use Cases**:
+- Create analysis reports
+- Build dashboards
+- Color-code data quality scores
+- Format tables with results
+
+**Best Practices**:
+- Use templates for consistent formatting
+- Include visualizations where helpful
+- Make reports mobile-friendly
+
+### Email (n8n-nodes-base.emailSend)
+
+**Purpose**: Send analysis reports to stakeholders automatically
+
+**Use Cases**:
+- Scheduled report delivery
+- Alert notifications
+- Share findings with teams
+
+**Best Practices**:
+- Use clear subject lines
+- Include summary in email body
+- Attach detailed reports when needed
+- Schedule appropriately
+
+## Common Pitfalls to Avoid
+
+### Data Type Mismatches
+
+**Problem**: JSON data types matter. Comparing string vs number yields incorrect results. The comparison "5" > "10" is lexicographically true (wrong for numbers).
+
+**Solution**:
+- Always convert data types before comparisons
+- Use Number() or parseInt() for numeric operations
+- Enable "Convert types where required" on IF nodes
+- Validate data types early in workflow
+- Use proper type casting in Code nodes
+
+### Memory Issues with Large Datasets
+
+**Problem**: Processing thousands of items at once can crash workflows or timeout.
+
+**Solution**:
+- Use Split In Batches node for datasets over 100 items
+- Set appropriate batch sizes (50-100 items)
+- Test with realistic data volumes during development
+- Monitor memory usage in production
+- Consider sub-workflows for complex processing
+
+### Not Pinning Data During Development
+
+**Problem**: Re-fetching data from APIs repeatedly wastes time and costs money during development.
+
+**Solution**:
+- Always pin data after external calls
+- Test downstream logic without re-fetching
+- Saves API costs and speeds development
+- Use manual triggers to control execution
+
+### Incorrect Aggregation Logic
+
+**Problem**: Using Function Item instead of Function node for whole-dataset calculations.
+
+**Solution**:
+- Use Function node (not Function Item) for totals, averages, trends
+- Function Item operates per item only
+- Understand the difference between item-level and dataset-level operations
+- Use Aggregate node for common operations
+
+### Missing Data Cleaning
+
+**Problem**: Null values, inconsistent formats, or outliers skew analysis results.
+
+**Solution**:
+- Use Filter node to remove null values
+- Standardize data formats early
+- Handle missing data explicitly
+- Use Set node to clean and normalize fields
+- Document data quality assumptions
+
+### Poor Error Handling
+
+**Problem**: Failed API calls or data issues break the entire workflow.
+
+**Solution**:
+- Use "Continue on Fail" setting appropriately
+- Add IF nodes to check for empty datasets
+- Implement error logging
+- Use Error Trigger workflows for global handling
+- Validate data quality before analysis
+
+### Hardcoded Values
+
+**Problem**: Thresholds, API endpoints, or configuration values are hardcoded in nodes.
+
+**Solution**:
+- Store configuration in environment variables
+- Use Google Sheets or databases for thresholds
+- Makes workflows reusable and maintainable
+- Enable non-technical users to adjust parameters
+
+### Inefficient Query Patterns
+
+**Problem**: Fetching entire datasets when only summary data is needed.
+
+**Solution**:
+- Use database aggregation functions
+- Filter data at the source
+- Use appropriate indexes
+- Implement pagination for large results
+- Consider pre-aggregated views
+`;
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.DataAnalysisBestPractices = DataAnalysisBestPractices;
+//# sourceMappingURL=data-analysis.js.map

package/dist/tools/best-practices/data-analysis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-analysis.js","sourceRoot":"","sources":["../../../src/tools/best-practices/data-analysis.ts"],"names":[],"mappings":";;;AACA,2DAA2D;AAE3D,MAAa,yBAAyB;IAC5B,SAAS,GAAG,kCAAiB,CAAC,aAAa,CAAC;IAC5C,OAAO,GAAG,OAAO,CAAC;IAEV,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiWjC,CAAC;IAED,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AA1WD,8DA0WC"}

package/dist/tools/best-practices/data-extraction.js

@@ -15,6 +15,13 @@ Use Information Extractor or AI nodes for extracting structured data from unstru
 
 For binary data, ensure you use nodes like Extract From File to handle files properly.
 
+### Referencing Binary Data from Other Nodes
+When you need to reference binary data from a previous node, use this syntax:
+- Expression: '{{ $('Node Name').item.binary.property_name }}' or {{ $binary.property_name }} if previous item
+- Example for Gmail attachments: '{{ $('Gmail Trigger').item.binary.attachment_0 }}' or {{ $binary.attachment_0 }} if previous item
+- Example for webhook data: '{{ $('Webhook').item.binary.data }}' or {{ $binary.data }} if previous item
+- Important: The property name depends on how the previous node names the binary data
+
 ## Data Structure & Type Management
 
 Normalize data structure early in your workflow. Use transformation nodes like Split Out, Aggregate, or Set to ensure your data matches n8n's expected structure: an array of objects with a json key.

package/dist/tools/best-practices/data-extraction.js.map

@@ -1 +1 @@
-{"version":3,"file":"data-extraction.js","sourceRoot":"","sources":["../../../src/tools/best-practices/data-extraction.ts"],"names":[],"mappings":";;;AACA,2DAA2D;AAE3D,MAAa,2BAA2B;IAC9B,SAAS,GAAG,kCAAiB,CAAC,eAAe,CAAC;IAC9C,OAAO,GAAG,OAAO,CAAC;IAEV,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2FjC,CAAC;IAED,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AApGD,kEAoGC"}
+{"version":3,"file":"data-extraction.js","sourceRoot":"","sources":["../../../src/tools/best-practices/data-extraction.ts"],"names":[],"mappings":";;;AACA,2DAA2D;AAE3D,MAAa,2BAA2B;IAC9B,SAAS,GAAG,kCAAiB,CAAC,eAAe,CAAC;IAC9C,OAAO,GAAG,OAAO,CAAC;IAEV,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkGjC,CAAC;IAED,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AA3GD,kEA2GC"}

package/dist/tools/best-practices/data-transformation.d.ts

@@ -0,0 +1,7 @@
+import type { BestPracticesDocument } from '../../types/best-practices';
+export declare class DataTransformationBestPractices implements BestPracticesDocument {
+    readonly technique: "data_transformation";
+    readonly version = "1.0.0";
+    private readonly documentation;
+    getDocumentation(): string;
+}

package/dist/tools/best-practices/data-transformation.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTransformationBestPractices = void 0;
+const categorization_1 = require("../../types/categorization");
+class DataTransformationBestPractices {
+    technique = categorization_1.WorkflowTechnique.DATA_TRANSFORMATION;
+    version = '1.0.0';
+    documentation = `# Best Practices: Data Transformation
+
+## Workflow Design
+
+### Core Principles
+- **Structure**: Always follow Input → Transform → Output pattern
+- **Modularity**: Break complex workflows into sub-workflows using Execute Workflow node
+- **Optimization**: Filter and reduce data early to improve performance
+- **Documentation**: Use descriptive node names and sticky notes for clarity
+- **Testing**: Test with edge cases (empty data, missing fields, special characters)
+
+### Design Best Practices
+- Plan transformation requirements in plain language before building
+- Keep main workflows to ~5 nodes, offload details to sub-workflows
+- Process inexpensive transformations first (especially data reduction)
+- Use Modular Design: Create reusable sub-workflows for common tasks like "Data Cleaning" or "Error Handler"
+- Batch large datasets using Split In Batches node to prevent timeouts
+
+## Error Handling
+- **Validate Early**: Use IF node at workflow start to check required fields and data types
+- **Error Outputs**: Connect red error output connectors to logging/notification chains
+- **Continue on Fail**: Enable in node settings to flag errors without breaking workflow
+- **Global Error Workflow**: Create separate workflow with Error Trigger node as safety net
+- **Logging**: Log key events with context (which record failed, error message, etc.)
+
+## Recommended Nodes
+
+### Essential Transformation Nodes
+
+#### Edit Fields (Set) (n8n-nodes-base.set)
+
+**Purpose**: Create, modify, rename fields; change data types
+
+**Key Setting**: "Keep Only Set" - drops all fields not explicitly defined (default: disabled)
+
+**Use Cases**:
+- Extract specific columns
+- Add calculated fields
+- Convert data types (string to number)
+- Format dates using expressions
+
+**Pitfalls**:
+- Not understanding "Keep Only Set" behavior can lead to data loss
+- Enabled: Drops all fields not explicitly defined (data loss risk)
+- Disabled: Carries forward all fields (potential bloat)
+- Always verify output structure after configuration
+
+#### IF/Filter Nodes
+
+**IF Node** (n8n-nodes-base.if):
+- **Purpose**: Conditional processing and routing
+- **Best Practice**: Use early to validate inputs and remove bad data
+- **Example**: Check if required fields exist before processing
+
+**Filter Node** (n8n-nodes-base.filter):
+- **Purpose**: Filter items based on conditions
+- **Best Practice**: Use early in workflow to reduce data volume
+
+#### Merge Node (n8n-nodes-base.merge)
+
+**Purpose**: Combine two data streams
+
+**Modes**:
+- Merge by Key (like database join)
+- Merge by Index
+- Append
+
+**Pitfalls**:
+- **Missing Keys**: Trying to merge on non-existent fields
+- **Field Name Mismatch**: Different field names in sources
+- **Solution**: Use Set node to normalize field names before merging
+
+#### Code Node (n8n-nodes-base.code)
+
+**When to Use**: Complex transformations impossible with built-in nodes
+
+**Execution Modes**:
+- "Run Once per Item": Process each item independently
+- "Run Once for All Items": Access entire dataset (for aggregation)
+
+**Return Format**: Must return array of objects with json property
+\`\`\`javascript
+return items; // or return [{ json: {...} }];
+\`\`\`
+
+**Pitfalls**:
+- Wrong return format: Not returning array of objects with json property
+- Overly complex: Stuffing entire workflow logic in one Code node
+- Keep code nodes focused on single transformation aspect
+
+#### Summarize Node (n8n-nodes-base.summarize)
+
+**Purpose**: Pivot table-style aggregations (count, sum, average, min/max)
+
+**Configuration**:
+- Fields to Summarize: Choose aggregation function
+- Fields to Split By: Grouping keys
+
+**Output**: Single item with summary or multiple items per group
+
+### Data Restructuring Nodes
+
+- **Split Out** (n8n-nodes-base.splitOut): Convert single item with array into multiple items
+- **Aggregate** (n8n-nodes-base.aggregate): Combine multiple items into one
+- **Remove Duplicates** (n8n-nodes-base.removeDuplicates): Delete duplicate items based on field criteria
+- **Sort** (n8n-nodes-base.sort): Order items alphabetically/numerically
+- **Limit** (n8n-nodes-base.limit): Trim to maximum number of items
+
+### Batch Processing
+
+**Split In Batches** (n8n-nodes-base.splitInBatches):
+- **Purpose**: Process large datasets in chunks
+- **Use When**: Handling 100+ items with expensive operations (API calls, AI)
+
+### Workflow Orchestration
+
+**Execute Workflow** (n8n-nodes-base.executeWorkflow):
+- **Purpose**: Call sub-workflows for modular design
+- **Best Practice**: Create reusable sub-workflows for common tasks like "Data Cleaning" or "Error Handler"
+
+**Error Trigger** (n8n-nodes-base.errorTrigger):
+- **Purpose**: Create global error handling workflow
+- **Best Practice**: Use as safety net to catch all workflow errors
+
+## Common Pitfalls to Avoid
+
+### Critical Mistakes
+
+#### Set Node Issues
+- **Mistake**: Not understanding "Keep Only Set" behavior
+  - Enabled: Drops all fields not explicitly defined (data loss risk)
+  - Disabled: Carries forward all fields (potential bloat)
+- **Solution**: Always verify output structure after configuration
+
+#### Code Node Errors
+- **Wrong Return Format**: Not returning array of objects with json property
+- **Fix**: Always return \`items\` or \`[{ json: {...} }]\`
+- **Overly Complex**: Stuffing entire workflow logic in one Code node
+- **Fix**: Keep code nodes focused on single transformation aspect
+
+#### Merge Node Problems
+- **Missing Keys**: Trying to merge on non-existent fields
+- **Fix**: Validate both inputs have matching key fields
+- **Field Name Mismatch**: Different field names in sources
+- **Fix**: Use Set node to normalize field names before merging
+
+### General Workflow Issues
+- **No Error Handling**: Workflow crashes on unexpected data
+- **Fix**: Add IF nodes for validation, use error outputs
+- **Hard-coded Values**: URLs, credentials, config in nodes
+- **Fix**: Use environment variables or config nodes
+- **Poor Naming**: Generic names like "Set1", "Function1"
+- **Fix**: Use descriptive names: "Clean Customer Data", "Calculate Totals"
+- **Missing Documentation**: No comments or descriptions
+- **Fix**: Add sticky notes, node descriptions, code comments
+
+### Performance Pitfalls
+- Processing large datasets without batching → timeouts
+- Not filtering early → unnecessary processing overhead
+- Excessive node chaining → visual clutter and slow execution
+- Not using sub-workflows → unmaintainable monolithic workflows
+
+### Data Validation Pitfalls
+- Assuming input data is always perfect
+- Not handling empty/null values
+- Ignoring data type mismatches
+- Missing edge case handling (special characters, empty arrays)
+`;
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.DataTransformationBestPractices = DataTransformationBestPractices;
+//# sourceMappingURL=data-transformation.js.map

package/dist/tools/best-practices/data-transformation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-transformation.js","sourceRoot":"","sources":["../../../src/tools/best-practices/data-transformation.ts"],"names":[],"mappings":";;;AACA,2DAA2D;AAE3D,MAAa,+BAA+B;IAClC,SAAS,GAAG,kCAAiB,CAAC,mBAAmB,CAAC;IAClD,OAAO,GAAG,OAAO,CAAC;IAEV,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuKjC,CAAC;IAED,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AAhLD,0EAgLC"}

package/dist/tools/best-practices/document-processing.d.ts

@@ -0,0 +1,7 @@
+import type { BestPracticesDocument } from '../../types/best-practices';
+export declare class DocumentProcessingBestPractices implements BestPracticesDocument {
+    readonly technique: "document_processing";
+    readonly version = "1.0.0";
+    private readonly documentation;
+    getDocumentation(): string;
+}