@synergenius/flow-weaver 0.2.0

package/dist/generator.d.ts

@@ -0,0 +1,54 @@
+import { type GenerateResult } from "./api/generate.js";
+export interface GeneratorOptions {
+    production?: boolean;
+    sourceMap?: boolean;
+}
+export type GeneratorResult = GenerateResult;
+/**
+ * Workflow Generator - Convenience wrapper with verbose logging
+ *
+ * This class provides a high-level interface for generating workflows
+ * with detailed console output. It orchestrates parsing, validation,
+ * and code generation while providing progress feedback.
+ *
+ * For programmatic use without console output, use the api/* modules directly:
+ * - parseWorkflow() - Parse workflow files to AST
+ * - validateWorkflow() - Validate workflow AST
+ * - generateCode() - Generate executable TypeScript
+ */
+export declare class WorkflowGenerator {
+    /**
+     * Generate executable TypeScript code from a workflow file
+     *
+     * This method performs three steps with verbose console output:
+     * 1. Parse the workflow file to extract node types and workflows
+     * 2. Validate the workflow structure and connections
+     * 3. Generate executable TypeScript code
+     *
+     * @param filePath - Path to the workflow file
+     * @param workflowName - Name of the workflow to generate
+     * @param options - Generation options (production mode, source maps)
+     * @returns Promise resolving to generated code string, or GeneratorResult with source map
+     *
+     * @throws Error if validation fails or workflow not found
+     */
+    generate(filePath: string, workflowName: string, options: GeneratorOptions & {
+        sourceMap: true;
+    }): Promise<GeneratorResult>;
+    generate(filePath: string, workflowName: string, options?: GeneratorOptions): Promise<string>;
+    /**
+     * Parse workflow file with detailed console logging
+     * @private
+     */
+    private parseWithLogging;
+    /**
+     * Validate workflow AST with detailed console logging
+     * @private
+     */
+    private validateWithLogging;
+}
+/**
+ * Default generator instance for convenience
+ */
+export declare const generator: WorkflowGenerator;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generator.js

@@ -0,0 +1,100 @@
+/* eslint-disable no-console */
+import { parseWorkflow } from "./api/parse.js";
+import { validateWorkflow } from "./api/validate.js";
+import { generateCode } from "./api/generate.js";
+/**
+ * Workflow Generator - Convenience wrapper with verbose logging
+ *
+ * This class provides a high-level interface for generating workflows
+ * with detailed console output. It orchestrates parsing, validation,
+ * and code generation while providing progress feedback.
+ *
+ * For programmatic use without console output, use the api/* modules directly:
+ * - parseWorkflow() - Parse workflow files to AST
+ * - validateWorkflow() - Validate workflow AST
+ * - generateCode() - Generate executable TypeScript
+ */
+export class WorkflowGenerator {
+    async generate(filePath, workflowName, options = {}) {
+        const { production = false, sourceMap = false } = options;
+        // Step 1: Parse
+        const parseResult = await this.parseWithLogging(filePath, workflowName);
+        // Step 2: Validate
+        this.validateWithLogging(parseResult.ast);
+        // Step 3: Generate
+        console.log("\\nGenerating workflow function body...");
+        // Call generateCode with the correct overload based on sourceMap
+        // Pass allWorkflows for local dependency generation
+        if (sourceMap) {
+            return generateCode(parseResult.ast, { production, sourceMap: true, allWorkflows: parseResult.allWorkflows });
+        }
+        return generateCode(parseResult.ast, { production, allWorkflows: parseResult.allWorkflows });
+    }
+    /**
+     * Parse workflow file with detailed console logging
+     * @private
+     */
+    async parseWithLogging(filePath, workflowName) {
+        console.log("Parsing annotations...");
+        const parseResult = await parseWorkflow(filePath, { workflowName });
+        if (parseResult.errors.length > 0) {
+            console.error(`\\n❌ ${parseResult.errors.length} parse error(s):`);
+            parseResult.errors.forEach((error) => {
+                console.error(`  - ${error}`);
+            });
+            throw new Error(`Workflow parsing failed with ${parseResult.errors.length} error(s)`);
+        }
+        // Log discovered node types
+        const nodeTypes = parseResult.ast.nodeTypes;
+        console.log(`Found ${nodeTypes.length} node types:`);
+        nodeTypes.forEach((nodeType) => {
+            console.log(`  - ${nodeType.functionName}`);
+        });
+        // Log available workflows
+        console.log(`Found ${parseResult.availableWorkflows.length} workflows:`);
+        parseResult.availableWorkflows.forEach((wf) => {
+            console.log(`  - ${wf}`);
+        });
+        return parseResult;
+    }
+    /**
+     * Validate workflow AST with detailed console logging
+     * @private
+     */
+    validateWithLogging(ast) {
+        console.log("Validating workflow...");
+        const validation = validateWorkflow(ast);
+        // Log warnings
+        if (validation.warnings.length > 0) {
+            console.log(`\\n⚠️  ${validation.warnings.length} warning(s):`);
+            validation.warnings.forEach((warning) => {
+                console.log(`  - ${warning.message}`);
+                if (warning.node) {
+                    console.log(`    at node: ${warning.node}`);
+                }
+            });
+            console.log("");
+        }
+        // Handle validation errors
+        if (!validation.valid) {
+            console.error(`\\n❌ ${validation.errors.length} validation error(s):`);
+            validation.errors.forEach((error) => {
+                console.error(`  - ${error.message}`);
+                if (error.node) {
+                    console.error(`    at node: ${error.node}`);
+                }
+                if (error.connection) {
+                    console.error(`    at connection: ${JSON.stringify(error.connection)}`);
+                }
+            });
+            throw new Error(`Workflow validation failed with ${validation.errors.length} error(s)`);
+        }
+        console.log("✓ Validation passed\\n");
+        return validation;
+    }
+}
+/**
+ * Default generator instance for convenience
+ */
+export const generator = new WorkflowGenerator();
+//# sourceMappingURL=generator.js.map

package/dist/index.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @packageDocumentation
+ *
+ * # Flow Weaver Library
+ *
+ * A visual dataflow programming system for TypeScript. Workflows are defined via
+ * JSDoc annotations in standard TypeScript files and can be parsed, validated,
+ * and compiled to executable code.
+ *
+ * ## Core Concepts
+ *
+ * - **Workflow** (`TWorkflowAST`) - A graph of connected nodes with start/exit ports
+ * - **NodeType** (`TNodeTypeAST`) - Template defining inputs, outputs, and behavior
+ * - **NodeInstance** (`TNodeInstanceAST`) - A usage of a node type in a workflow
+ * - **Port** (`TPortDefinition`) - Entry/exit point on a node (data or control flow)
+ * - **Connection** (`TConnectionAST`) - Links ports between nodes
+ *
+ * ## File Format
+ *
+ * Any `.ts`, `.tsx`, `.js`, or `.jsx` file can contain workflows.
+ *
+ * ```typescript
+ * // Define a node type
+ * /**
+ *  * @flowWeaver nodeType
+ *  * @input a - First number
+ *  * @input b - Second number
+ *  * @output result - Sum
+ *  *\/
+ * function add(execute: boolean, a: number, b: number): { onSuccess: boolean; result: number } { ... }
+ *
+ * // Define a workflow
+ * /**
+ *  * @flowWeaver workflow
+ *  * @node adder1 add
+ *  * @connect Start.execute -> adder1.execute
+ *  * @connect adder1.onSuccess -> Exit.onSuccess
+ *  *\/
+ * export function myWorkflow(execute: boolean, params: {...}): {...} { ... }
+ * ```
+ *
+ * ## Main APIs
+ *
+ * - {@link parseWorkflow} - Parse a file to AST
+ * - {@link validateWorkflow} - Validate workflow structure
+ * - {@link generateCode} - Generate executable code from AST
+ * - {@link compileWorkflow} - Parse + validate + generate in one step
+ *
+ * ## JSDoc Port Sync (Browser-compatible)
+ *
+ * For IDE integration, use the browser-compatible sync functions:
+ * - {@link parsePortsFromFunctionText} - Extract ports from JSDoc
+ * - {@link updatePortsInFunctionText} - Update ports in function text
+ * - {@link formatPortsInFunctionText} - Format ports consistently
+ *
+ * @module @synergenius/flow-weaver
+ */
+export * from './api/index.js';
+export { parser, resolveNpmNodeTypes } from './parser.js';
+export type { TExternalNodeType } from './parser.js';
+export type { TConnectionAST, TNodeTypeAST, TNodeInstanceAST, TNodeInstanceConfig, TPortConfig, TWorkflowAST, TPortReference, TPortDefinition, TDataType, TExecuteWhen, TBranchingStrategy, TSerializableValue, TSerializableObject, TSerializableArray, TImportDeclaration, TImportSpecifier, TSourceLocation, TValidationError, TAnalysisResult, TControlFlowGraph, TControlFlowEdge, TBranchingNodeInfo, TBranchRegion, TMergeNodeInfo, TWorkflowMetadata, TNodeMetadata, TConnectionMetadata, TASTTransformer, TASTVisitor, TParseOptions, TValidationRule, TGenerateOptions, TCompileResult, TCompilationMetadata, TNodeTypeDefaultConfig, TNodeTypePort, TPortDirection, TNodeParent, TPullExecutionConfig, TWorkflowFileExtension, TPortPlacement, TPortUI, TNodeTypeUI, TNodeUI, TWorkFlowFunctionUI, TPortType, } from './ast/types.js';
+export { WorkflowBuilder, NodeTypeBuilder, NodeInstanceBuilder, ConnectionBuilder, } from './ast/builder.js';
+export { portRef, port, workflow, nodeType, nodeInstance } from './ast/builder.js';
+export { GeneratedExecutionContext } from './runtime/ExecutionContext.js';
+export type { TDebugger } from './runtime/events.js';
+export type { TLocalFunctionNodeType } from './node-types-generator.js';
+export { configureGeneratedBranding, getGeneratedBranding } from './generated-branding.js';
+export type { GeneratedBranding } from './generated-branding.js';
+export * from './type-mappings.js';
+export * from './constants.js';
+export { validator, WorkflowValidator } from './validator.js';
+export { getFriendlyError, formatFriendlyDiagnostics } from './friendly-errors.js';
+export type { TFriendlyError } from './friendly-errors.js';
+export { generator, WorkflowGenerator } from './generator.js';
+export { AnnotationGenerator } from './annotation-generator.js';
+export type { GenerateAnnotationsOptions } from './annotation-generator.js';
+export * as GeneratorUtils from './generator.js';
+export { parsePortsFromFunctionText, updatePortsInFunctionText, formatPortsInFunctionText, syncCodeRenames, renamePortInCode, parseReturnTypeFields, parseFunctionSignature, parseReturnFields, } from './jsdoc-port-sync.js';
+export { workflowTemplates, nodeTemplates, getWorkflowTemplate, getNodeTemplate, toCamelCase, toPascalCase, } from './cli/templates/index.js';
+export type { WorkflowTemplate, NodeTemplate, WorkflowTemplateOptions } from './cli/templates/index.js';
+export { WorkflowDiffer } from './diff/WorkflowDiffer.js';
+export { formatDiff, type TDiffFormat } from './diff/formatDiff.js';
+export { IMPACT_DESCRIPTIONS, IMPACT_COLORS, getImpactReasons, hasBreakingChanges, getNodeTypeChanges, getCriticalConnections, } from './diff/impact.js';
+export type { TWorkflowDiff, TNodeTypeDiff, TInstanceDiff, TConnectionDiff, TWorkflowPortsDiff, TScopeDiff, TPortChange, TImpactLevel, TChangeType, TChange, TInstanceConfigChange, TPortRef, } from './diff/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,89 @@
+/**
+ * @packageDocumentation
+ *
+ * # Flow Weaver Library
+ *
+ * A visual dataflow programming system for TypeScript. Workflows are defined via
+ * JSDoc annotations in standard TypeScript files and can be parsed, validated,
+ * and compiled to executable code.
+ *
+ * ## Core Concepts
+ *
+ * - **Workflow** (`TWorkflowAST`) - A graph of connected nodes with start/exit ports
+ * - **NodeType** (`TNodeTypeAST`) - Template defining inputs, outputs, and behavior
+ * - **NodeInstance** (`TNodeInstanceAST`) - A usage of a node type in a workflow
+ * - **Port** (`TPortDefinition`) - Entry/exit point on a node (data or control flow)
+ * - **Connection** (`TConnectionAST`) - Links ports between nodes
+ *
+ * ## File Format
+ *
+ * Any `.ts`, `.tsx`, `.js`, or `.jsx` file can contain workflows.
+ *
+ * ```typescript
+ * // Define a node type
+ * /**
+ *  * @flowWeaver nodeType
+ *  * @input a - First number
+ *  * @input b - Second number
+ *  * @output result - Sum
+ *  *\/
+ * function add(execute: boolean, a: number, b: number): { onSuccess: boolean; result: number } { ... }
+ *
+ * // Define a workflow
+ * /**
+ *  * @flowWeaver workflow
+ *  * @node adder1 add
+ *  * @connect Start.execute -> adder1.execute
+ *  * @connect adder1.onSuccess -> Exit.onSuccess
+ *  *\/
+ * export function myWorkflow(execute: boolean, params: {...}): {...} { ... }
+ * ```
+ *
+ * ## Main APIs
+ *
+ * - {@link parseWorkflow} - Parse a file to AST
+ * - {@link validateWorkflow} - Validate workflow structure
+ * - {@link generateCode} - Generate executable code from AST
+ * - {@link compileWorkflow} - Parse + validate + generate in one step
+ *
+ * ## JSDoc Port Sync (Browser-compatible)
+ *
+ * For IDE integration, use the browser-compatible sync functions:
+ * - {@link parsePortsFromFunctionText} - Extract ports from JSDoc
+ * - {@link updatePortsInFunctionText} - Update ports in function text
+ * - {@link formatPortsInFunctionText} - Format ports consistently
+ *
+ * @module @synergenius/flow-weaver
+ */
+// Public API
+export * from './api/index.js';
+// Parser (for advanced use - clearing import cache)
+export { parser, resolveNpmNodeTypes } from './parser.js';
+// AST Builders (for programmatic AST construction)
+export { WorkflowBuilder, NodeTypeBuilder, NodeInstanceBuilder, ConnectionBuilder, } from './ast/builder.js';
+export { portRef, port, workflow, nodeType, nodeInstance } from './ast/builder.js';
+// Runtime
+export { GeneratedExecutionContext } from './runtime/ExecutionContext.js';
+// Generated Branding (configurable output branding)
+export { configureGeneratedBranding, getGeneratedBranding } from './generated-branding.js';
+// Type Mappings & Constants
+export * from './type-mappings.js';
+export * from './constants.js';
+// Validation
+export { validator, WorkflowValidator } from './validator.js';
+// Friendly Errors (beginner-friendly validation messages)
+export { getFriendlyError, formatFriendlyDiagnostics } from './friendly-errors.js';
+// Code Generation
+export { generator, WorkflowGenerator } from './generator.js';
+export { AnnotationGenerator } from './annotation-generator.js';
+// Generator Utilities (for advanced use)
+export * as GeneratorUtils from './generator.js';
+// JSDoc Port Sync (browser-compatible parsing/updating)
+export { parsePortsFromFunctionText, updatePortsInFunctionText, formatPortsInFunctionText, syncCodeRenames, renamePortInCode, parseReturnTypeFields, parseFunctionSignature, parseReturnFields, } from './jsdoc-port-sync.js';
+// Templates (for workflow/node creation)
+export { workflowTemplates, nodeTemplates, getWorkflowTemplate, getNodeTemplate, toCamelCase, toPascalCase, } from './cli/templates/index.js';
+// Diff (semantic comparison)
+export { WorkflowDiffer } from './diff/WorkflowDiffer.js';
+export { formatDiff } from './diff/formatDiff.js';
+export { IMPACT_DESCRIPTIONS, IMPACT_COLORS, getImpactReasons, hasBreakingChanges, getNodeTypeChanges, getCriticalConnections, } from './diff/impact.js';
+//# sourceMappingURL=index.js.map

package/dist/jsdoc-parser.d.ts

@@ -0,0 +1,308 @@
+/**
+ * JSDoc annotation parser for Flow Weaver
+ *
+ * Parses @flowWeaver annotations from JSDoc comments.
+ */
+import type { FunctionLike } from './function-like.js';
+import type { TDataType, TPortConfig, TMergeStrategy, TNodeTagAST } from './ast/types.js';
+export interface JSDocNodeTypeConfig {
+    name?: string;
+    label?: string;
+    description?: string;
+    color?: string;
+    icon?: string;
+    tags?: Array<{
+        label: string;
+        tooltip?: string;
+    }>;
+    executeWhen?: string;
+    scope?: string;
+    expression?: boolean;
+    defaultConfig?: {
+        pullExecution?: {
+            triggerPort: string;
+        };
+        label?: string;
+        description?: string;
+    };
+    inputs?: Record<string, {
+        type: TDataType;
+        defaultValue?: unknown;
+        optional?: boolean;
+        label?: string;
+        expression?: string;
+        scope?: string;
+        mergeStrategy?: TMergeStrategy;
+        metadata?: {
+            order?: number;
+        };
+        tsType?: string;
+    }>;
+    outputs?: Record<string, {
+        type: TDataType;
+        label?: string;
+        scope?: string;
+        metadata?: {
+            order?: number;
+        };
+        tsType?: string;
+    }>;
+}
+export interface JSDocWorkflowConfig {
+    name?: string;
+    description?: string;
+    strictTypes?: boolean;
+    /** NPM package imports - external node types persisted in JSDoc */
+    imports?: Array<{
+        name: string;
+        functionName: string;
+        importSource: string;
+    }>;
+    instances?: Array<{
+        id: string;
+        type: string;
+        parentScope?: string;
+        label?: string;
+        portConfigs?: TPortConfig[];
+        pullExecution?: {
+            triggerPort: string;
+        };
+        minimized?: boolean;
+        color?: string;
+        icon?: string;
+        tags?: TNodeTagAST[];
+        width?: number;
+        height?: number;
+        sourceLocation?: {
+            line: number;
+            column: number;
+        };
+    }>;
+    connections?: Array<{
+        from: {
+            node: string;
+            port: string;
+            scope?: string;
+        };
+        to: {
+            node: string;
+            port: string;
+            scope?: string;
+        };
+        sourceLocation?: {
+            line: number;
+            column: number;
+        };
+    }>;
+    scopes?: Record<string, string[]>;
+    layout?: Record<string, {
+        x: number;
+        y: number;
+    }>;
+    startPorts?: Record<string, {
+        dataType?: TDataType;
+        label?: string;
+        metadata?: {
+            order?: number;
+        };
+    }>;
+    returnPorts?: Record<string, {
+        dataType: TDataType;
+        label?: string;
+        metadata?: {
+            order?: number;
+        };
+    }>;
+    positions?: Record<string, {
+        x: number;
+        y: number;
+    }>;
+    /** When true, auto-wire linear connections between nodes in declaration order */
+    autoConnect?: boolean;
+    /** @map sugar macros that expand to full scope patterns */
+    maps?: Array<{
+        instanceId: string;
+        childId: string;
+        sourceNode: string;
+        sourcePort: string;
+        inputPort?: string;
+        outputPort?: string;
+    }>;
+    /** @path sugar macros that expand to multi-step execution routes with scope walking */
+    paths?: Array<{
+        steps: Array<{
+            node: string;
+            route?: 'ok' | 'fail';
+        }>;
+    }>;
+    /** @trigger annotation — event name and/or cron schedule */
+    trigger?: {
+        event?: string;
+        cron?: string;
+    };
+    /** @cancelOn annotation — cancel on matching external event */
+    cancelOn?: {
+        event: string;
+        match?: string;
+        timeout?: string;
+    };
+    /** @retries annotation — retry count */
+    retries?: number;
+    /** @timeout annotation — function-level timeout */
+    timeout?: string;
+    /** @throttle annotation — rate limiting */
+    throttle?: {
+        limit: number;
+        period?: string;
+    };
+}
+export interface JSDocPatternConfig {
+    name?: string;
+    description?: string;
+    instances?: Array<{
+        id: string;
+        nodeType: string;
+        config?: {
+            x?: number;
+            y?: number;
+        };
+    }>;
+    connections?: Array<{
+        from: {
+            node: string;
+            port: string;
+        };
+        to: {
+            node: string;
+            port: string;
+        };
+    }>;
+    ports?: Array<{
+        direction: 'IN' | 'OUT';
+        name: string;
+        description?: string;
+    }>;
+    positions?: Record<string, {
+        x: number;
+        y: number;
+    }>;
+}
+export declare class JSDocParser {
+    /**
+     * Parse @flowWeaver nodeType from JSDoc comments
+     */
+    parseNodeType(func: FunctionLike, warnings: string[]): JSDocNodeTypeConfig | null;
+    /**
+     * Parse @flowWeaver workflow from JSDoc comments
+     */
+    parseWorkflow(func: FunctionLike, warnings: string[]): JSDocWorkflowConfig | null;
+    /**
+     * Parse @flowWeaver pattern from JSDoc comments
+     */
+    parsePattern(func: FunctionLike, warnings: string[]): JSDocPatternConfig | null;
+    /**
+     * Parse @node tag for patterns.
+     * Format: @node instanceId nodeType
+     */
+    private parsePatternNodeTag;
+    /**
+     * Parse @position tag for patterns.
+     * Format: @position nodeId x y
+     */
+    private parsePatternPositionTag;
+    /**
+     * Parse @connect tag for patterns.
+     * Supports IN/OUT pseudo-nodes: IN.port -> node.port, node.port -> OUT.port
+     */
+    private parsePatternConnectTag;
+    /**
+     * Parse @port tag for patterns.
+     * Format: @port IN.name - description OR @port OUT.name - description
+     */
+    private parsePatternPortTag;
+    /**
+     * Parse @input tag using Chevrotain parser.
+     * Supports: @input name, @input [name], @input [name=default]
+     * With optional: scope:scopeName, [order:N], [placement:TOP/BOTTOM], - description
+     */
+    private parseInputTag;
+    /**
+     * Parse @output tag using Chevrotain parser.
+     * Supports: @output name, scope:scopeName, [order:N], - description
+     */
+    private parseOutputTag;
+    /**
+     * Parse @step tag using Chevrotain parser.
+     * Used for explicit STEP/control-flow ports that are not reserved.
+     */
+    private parseStepTag;
+    /**
+     * Parse @return/@returns tag for workflow functions using Chevrotain.
+     * Format: @returns name [order:N] - Description (type inferred from signature)
+     */
+    private parseReturnTag;
+    /**
+     * Parse @param tag for workflow functions using Chevrotain.
+     * Format: @param name [order:N] - Description (type inferred from signature)
+     */
+    private parseParamTag;
+    /**
+     * Parse @fwImport tag for npm package node types.
+     * Format: @fwImport nodeName functionName from "packageName"
+     * Examples:
+     *   @fwImport npm/autoprefixer/autoprefixer autoprefixer from "autoprefixer"
+     *   @fwImport npm/lodash/map map from "lodash"
+     * Note: We use @fwImport instead of @import because TypeScript treats @import specially
+     * and truncates the first word as a type annotation.
+     */
+    private parseImportTag;
+    /**
+     * Parse @node tag using Chevrotain parser.
+     * Supports: @node instanceId nodeType [parentScope] [label: "..."] [portOrder: port=N] [portLabel: port="label"] [expr: port="val"] [minimized] [pullExecution: triggerPort]
+     */
+    private parseNodeTag;
+    /**
+     * Parse @position tag using Chevrotain parser.
+     * Supports: @position nodeId x y
+     */
+    private parsePositionTag;
+    /**
+     * Parse @connect tag using Chevrotain parser.
+     * Supports: node.port -> node.port and node.port:scope -> node.port:scope
+     */
+    private parseConnectTag;
+    /**
+     * Parse @scope tag using Chevrotain parser.
+     * Format: @scope scopeName [child1, child2] or @scope container.scopeName [child1, child2]
+     */
+    private parseScopeTag;
+    /**
+     * Parse @map tag using Chevrotain parser.
+     * Format: @map instanceId childNode over source.port
+     * Or:     @map instanceId childNode(inputPort -> outputPort) over source.port
+     */
+    private parseMapTag;
+    /**
+     * Parse @path tag using Chevrotain parser.
+     * Format: @path Start -> validator:ok -> classifier -> urgencyRouter:fail -> escalate -> Exit
+     */
+    private parsePathTag;
+    /**
+     * Parse @trigger tag using Chevrotain parser.
+     */
+    private parseTriggerTag;
+    /**
+     * Parse @cancelOn tag using Chevrotain parser.
+     */
+    private parseCancelOnTag;
+    /**
+     * Parse @throttle tag using Chevrotain parser.
+     */
+    private parseThrottleTag;
+    /**
+     * Parse default value from string
+     */
+    private parseDefaultValue;
+}
+export declare const jsdocParser: JSDocParser;
+//# sourceMappingURL=jsdoc-parser.d.ts.map