/**
 * # Flow Weaver Constants
 *
 * This module defines reserved names and constants used throughout the Flow Weaver system.
 *
 * ## Scoped Port Architecture
 *
 * Scoped ports enable iteration patterns (forEach, map) WITHOUT graph cycles.
 * The key insight is that port directions are INVERTED for scoped ports:
 *
 * ```
 * ┌─────────────────────────────────────────────────────────────────────┐
 * │                    SCOPED PORT DIRECTION MAPPING                    │
 * ├─────────────────┬──────────┬────────────────────────────────────────┤
 * │ Scoped OUTPUT   │ Parent→  │ Parameters TO children (start, item)   │
 * │ Scoped INPUT    │ →Parent  │ Returns FROM children (success, result)│
 * └─────────────────┴──────────┴────────────────────────────────────────┘
 * ```
 *
 * **Why this inversion?**
 * - Scoped OUTPUT ports (like `start`, `item`) are data the parent SENDS to nested nodes
 * - Scoped INPUT ports (like `success`, `result`) are data the parent RECEIVES from nested nodes
 * - The loop iteration happens in the parent's imperative code, not as graph cycles
 *
 * ## Mandatory Scoped Ports
 *
 * Every scoped node must have these ports for each scope it declares:
 * - `start` (OUTPUT) - Triggers scope execution, passed as first param
 * - `success` (INPUT) - Signals successful completion from child
 * - `failure` (INPUT) - Signals failure from child
 *
 * ## Example: forEach Node
 *
 * ```typescript
 * @scope processItem
 * @output start scope:processItem    // OUTPUT → function param (triggers iteration)
 * @output item scope:processItem     // OUTPUT → function param (current item)
 * @input success scope:processItem   // INPUT → return value (completion signal)
 * @input processed scope:processItem // INPUT → return value (processed data)
 *
 * function forEach(execute, items, processItem) {
 *   const results = [];
 *   for (const item of items) {
 *     const r = processItem(true, item); // Calls generated closure
 *     if (r.success) results.push(r.processed);
 *   }
 *   return { onSuccess: true, results };
 * }
 * ```
 */
export declare const RESERVED_NODE_NAMES: {
    readonly START: "Start";
    readonly EXIT: "Exit";
};
export declare const RESERVED_PORT_NAMES: {
    readonly EXECUTE: "execute";
    readonly ON_SUCCESS: "onSuccess";
    readonly ON_FAILURE: "onFailure";
};
export declare const SCOPED_PORT_NAMES: {
    readonly START: "start";
    readonly SUCCESS: "success";
    readonly FAILURE: "failure";
};
export declare const EXECUTION_STRATEGIES: {
    readonly CONJUNCTION: "CONJUNCTION";
    readonly DISJUNCTION: "DISJUNCTION";
    readonly CUSTOM: "CUSTOM";
};
export declare const BRANCHING_STRATEGIES: {
    readonly VALUE_BASED: "value-based";
    readonly EXCEPTION_BASED: "exception-based";
    readonly NONE: "none";
};
export type ReservedNodeName = (typeof RESERVED_NODE_NAMES)[keyof typeof RESERVED_NODE_NAMES];
export type ReservedPortName = (typeof RESERVED_PORT_NAMES)[keyof typeof RESERVED_PORT_NAMES];
export type ExecutionStrategy = (typeof EXECUTION_STRATEGIES)[keyof typeof EXECUTION_STRATEGIES];
export type BranchingStrategyType = (typeof BRANCHING_STRATEGIES)[keyof typeof BRANCHING_STRATEGIES];
export declare function isReservedNodeName(name: string): name is ReservedNodeName;
export declare function isReservedPortName(name: string): name is ReservedPortName;
export declare function isStartNode(nodeName: string): boolean;
export declare function isExitNode(nodeName: string): boolean;
export declare function isSpecialNode(nodeName: string): boolean;
/** Pseudo-nodes like `secret:NAME` are connection sources that don't correspond to real node instances. */
export declare function isPseudoNode(nodeName: string): boolean;
export declare function isExecutePort(portName: string): boolean;
export declare function isSuccessPort(portName: string): boolean;
export declare function isFailurePort(portName: string): boolean;
export declare function isScopedStartPort(portName: string): boolean;
export declare function isScopedSuccessPort(portName: string): boolean;
export declare function isScopedFailurePort(portName: string): boolean;
export declare function isScopedMandatoryPort(portName: string): boolean;
export declare function isControlFlowPort(portName: string): boolean;
/**
 * Check if a port definition represents a scoped port
 * Scoped ports are FUNCTION type with a scope attribute
 */
export declare function isScopedPort(portDef: {
    dataType: string;
    scope?: string;
}): boolean;
export declare const VALID_NODE_COLORS: readonly ["blue", "purple", "cyan", "orange", "pink", "green", "red", "yellow", "teal"];
export type ValidNodeColor = (typeof VALID_NODE_COLORS)[number];
export declare const KNOWN_NODETYPE_TAGS: Set<string>;
export declare const KNOWN_WORKFLOW_TAGS: Set<string>;
export declare const KNOWN_PATTERN_TAGS: Set<string>;
export declare const STANDARD_JSDOC_TAGS: Set<string>;
/**
 * Build a dynamic known-workflow-tags set that includes core tags
 * plus any extra tags contributed by pack registries.
 */
export declare function getKnownWorkflowTags(extraTags?: string[]): Set<string>;
//# sourceMappingURL=constants.d.ts.map