/**
 * @pm4py/pm4wasm
 *
 * High-level TypeScript API for the POWL v2 Rust/WASM library.
 *
 * Usage:
 * ```ts
 * import { Powl } from "@pm4py/pm4wasm";
 *
 * const powl = await Powl.init();
 * const model = powl.parse("X(A, B)");
 * console.log(model.toString());       // "X ( A, B )"
 * const pn = model.toPetriNet();
 * const fitness = powl.conformance(pn, log);
 * ```
 */
import type { EventLog, FitnessResult, Footprints, NodeInfo, PetriNetResult, ModelFootprints, FootprintsConformanceResult, SoundnessResult, StreamingConformanceSnapshot, AttributeValue, CaseDurationResult, ReworkTime, TraceReplayResult, PrecisionResult } from "./types.js";
export type * from "./types.js";
export * from "./utils.js";
export * from "./validation.js";
export * from "./llm-prompts.js";
export * from "./model-generator.js";
export * from "./refinement-loop.js";
export * from "./error-handler.js";
export * from "./process-modeling-service.js";
export * from "./predictive.js";
type WasmModule = typeof import("../pkg/pm4wasm.js");
/**
 * An opaque handle to a parsed POWL model in WASM memory.
 *
 * Obtain via `Powl.parse()` — do not construct directly.
 */
export declare class PowlModel {
    /** @internal */ private readonly _wm;
    /** @internal */
    private readonly _handle;
    /** @internal */
    constructor(
    /** @internal */ _wm: WasmModule, handle: any);
    /** @internal */
    get __handle(): any;
    /** Arena index of the root node. */
    get root(): number;
    /** Total number of nodes in the arena. */
    get size(): number;
    /** Canonical string representation (matches Python `__repr__`). */
    toString(): string;
    /** Return typed info about a node by arena index. */
    nodeInfo(arenaIdx: number): NodeInfo;
    /** Child arena indices of an operator or SPO node; empty for leaves. */
    children(arenaIdx: number): number[];
    /** String representation of one node. */
    nodeToString(arenaIdx: number): string;
    /**
     * Validate all StrictPartialOrder nodes.
     * @throws {Error} if any violation is found.
     */
    validate(): void;
    /** Return a new simplified model (structure-normalized). */
    simplify(): PowlModel;
    /** Convert XOR(A,tau) / LOOP(A,tau) patterns to FrequentTransitions. */
    simplifyFrequent(): PowlModel;
    /** Convert to Petri net. */
    toPetriNet(): PetriNetResult;
    /**
     * Compute footprints (behavioural signature).
     *
     * @returns JSON-parsed footprints object.
     */
    footprints(): Footprints;
    /**
     * Walk every node in the tree, depth-first (pre-order).
     * Calls `visitor(arenaIdx, info)` for each node.
     */
    walk(visitor: (idx: number, info: NodeInfo) => void): void;
    /**
     * Collect all activity labels in the model (leaf Transitions with non-null label).
     */
    activities(): Set<string>;
    /** Raw ordering relation of an SPO node as flat edge list `[src, tgt, …]`. */
    orderEdges(spoIdx: number): number[];
    /** Transitive closure edges of an SPO node. */
    closureEdges(spoIdx: number): number[];
    /** Transitive reduction edges of an SPO node. */
    reductionEdges(spoIdx: number): number[];
}
/**
 * Entry-point for the POWL WASM library.
 *
 * ```ts
 * const powl = await Powl.init();
 * ```
 */
export declare class Powl {
    private readonly wm;
    /** @internal */
    private constructor();
    /**
     * Initialise the WASM module and return a ready-to-use `Powl` instance.
     * Safe to call multiple times — the WASM module is loaded only once.
     */
    static init(): Promise<Powl>;
    /**
     * Parse a POWL model string (Python `__repr__` format).
     *
     * @throws {Error} on syntax error.
     *
     * @example
     * ```ts
     * const m = powl.parse("X(A, B)");
     * const spo = powl.parse("PO=(nodes={A, B, C}, order={A-->B, A-->C})");
     * ```
     */
    parse(s: string): PowlModel;
    /**
     * Parse a XES-formatted XML string.
     *
     * @throws {Error} on XML parse failure.
     */
    parseXes(xml: string): EventLog;
    /**
     * Parse a CSV string with headers.
     *
     * Required columns: `case_id` / `case:concept:name`, `activity` / `concept:name`.
     * Optional: `timestamp` / `time:timestamp`.
     *
     * @throws {Error} on parse failure.
     *
     * @example
     * ```ts
     * const log = powl.parseCsv(
     *   "case_id,activity,timestamp\n" +
     *   "1,A,2020-01-01\n" +
     *   "1,B,2020-01-02\n"
     * );
     * ```
     */
    parseCsv(csv: string): EventLog;
    /**
     * Fetch and parse an XES file from a URL.
     *
     * @example
     * ```ts
     * const log = await powl.fetchXes("/logs/running-example.xes");
     * ```
     */
    fetchXes(url: string): Promise<EventLog>;
    /**
     * Parse an XES `File` object from a drag-and-drop or `<input type="file">`.
     *
     * @example
     * ```ts
     * input.addEventListener("change", async (e) => {
     *   const log = await powl.readXesFile(e.target.files[0]);
     * });
     * ```
     */
    readXesFile(file: File): Promise<EventLog>;
    /** Parse a CSV `File` object. */
    readCsvFile(file: File): Promise<EventLog>;
    /**
     * Compute token-replay fitness of an event log against a POWL model.
     *
     * Internally converts the model to a Petri net then runs token replay.
     *
     * @example
     * ```ts
     * const model = powl.parse("PO=(nodes={A, B, C}, order={A-->B, B-->C})");
     * const log   = powl.parseCsv("case_id,activity\n1,A\n1,B\n1,C\n");
     * const fit   = powl.conformance(model, log);
     * console.log(fit.percentage);  // 1.0
     * ```
     */
    conformance(model: PowlModel, log: EventLog): FitnessResult;
    /**
     * Compute token-replay fitness given a pre-built `PetriNetResult`.
     * Use when you already have a Petri net and want to avoid recomputing it.
     */
    conformancePetriNet(pn: PetriNetResult, log: EventLog): FitnessResult;
    /**
     * Compute ETConformance precision for a Petri net against an event log.
     *
     * Precision measures how precisely the model describes observed behavior.
     * A score of 1.0 means the model allows exactly the behavior seen in the log.
     * A lower score means the model permits transitions that were never used
     * (escaping edges).
     *
     * @param model - Petri net result from discovery or conversion.
     * @param log - Event log to evaluate against.
     * @returns Precision result with score and token counts.
     *
     * @example
     * ```ts
     * const pn = powl.discoverPetriNet(log);
     * const prec = powl.precisionEtconformance(pn, log);
     * console.log(prec.precision); // 0.85
     * ```
     */
    precisionEtconformance(model: PetriNetResult, log: EventLog): PrecisionResult;
    /**
     * Get non-fitting traces from a conformance result.
     *
     * @param result Fitness result from `conformance()` or `conformancePetriNet()`.
     * @returns Array of trace results where `trace_is_fit` is `false`.
     */
    static getNonFittingTraces(result: FitnessResult): TraceReplayResult[];
    /**
     * Get transition firing sequence for a specific case.
     *
     * @param result Fitness result from `conformance()` or `conformancePetriNet()`.
     * @param caseId The case ID to look up.
     * @returns Ordered list of transition names fired during replay, or empty array if not found.
     */
    static getTransitionSequence(result: FitnessResult, caseId: string): string[];
    /**
     * Get diagnostic summary for all traces.
     *
     * Returns non-fitting traces and a frequency map of all transitions fired.
     *
     * @param result Fitness result from `conformance()` or `conformancePetriNet()`.
     */
    static getDiagnosticSummary(result: FitnessResult): {
        non_fitting: TraceReplayResult[];
        transition_frequency: Record<string, number>;
    };
    /**
     * Filter an event log to only traces whose fitness meets a threshold.
     *
     * @param threshold Minimum fitness score (0..1), default 0.8.
     */
    filterByFitness(model: PowlModel, log: EventLog, threshold?: number): EventLog;
    /**
     * Return variant statistics for an event log.
     *
     * @returns Map from activity sequence (joined by "→") to count.
     */
    variants(log: EventLog): Map<string, number>;
    /**
     * Compute the structural and behavioural diff between two POWL model strings.
     *
     * @param modelA First model string.
     * @param modelB Second model string.
     * @returns Diff result with added/removed activities and structural changes.
     *
     * @example
     * ```ts
     * const diff = powl.diffModels("X(A, B)", "X(A, B, C)");
     * console.log(diff.added_activities); // ["C"]
     * ```
     */
    diffModels(modelA: string, modelB: string): Record<string, unknown>;
    /**
     * Convert a POWL model string to BPMN 2.0 XML.
     *
     * @param modelStr POWL model string.
     * @returns Complete BPMN XML document importable by Camunda, Signavio, etc.
     */
    toBpmn(modelStr: string): string;
    /**
     * Convert a PetriNetResult to PNML 2.0 XML format.
     *
     * Takes the output of `toPetriNet()` or `discoverPetriNetInductive()`
     * and converts it to PNML XML for import into tools like PNEditor,
     * WoPeD, or ProM.
     *
     * Mirrors `pm4py.write_pnml()`.
     *
     * @example
     * ```ts
     * const model = powl.parse("PO=(nodes={A, B}, order={A-->B})");
     * const pn = model.toPetriNet();
     * const pnml = powl.toPnml(JSON.stringify(pn));
     * // Save pnml to file, open in PNEditor
     * ```
     *
     * @param petriNetJson JSON string of PetriNetResult.
     * @returns PNML 2.0 XML string.
     */
    toPnml(petriNetJson: string): string;
    /**
     * Replace activity labels in a POWL model.
     *
     * Mirrors `pm4py.objects.powl.utils.label_replacing.apply()`.
     *
     * @param modelStr POWL model string representation.
     * @param labelMap Object mapping old labels to new labels (e.g., {"A": "Start", "B": "End"}).
     * @returns New POWL model string with labels replaced.
     */
    replaceLabels(modelStr: string, labelMap: Record<string, string>): string;
    /**
     * Compute complexity metrics for a POWL model.
     *
     * @param model Parsed POWL model.
     * @returns Object with cyclomatic, CFC, cognitive, nesting_depth, etc.
     */
    complexity(model: PowlModel): Record<string, number>;
    /** Get start activities with frequencies. */
    getStartActivities(log: EventLog): import("./types.js").ActivityFrequency[];
    /** Get end activities with frequencies. */
    getEndActivities(log: EventLog): import("./types.js").ActivityFrequency[];
    /** Get all variants with frequencies and percentages. */
    getVariants(log: EventLog): import("./types.js").VariantInfo[];
    /** Get all event attribute keys with statistics. */
    getEventAttributes(log: EventLog): import("./types.js").AttributeSummary[];
    /** Get all trace attribute keys with statistics. */
    getTraceAttributes(log: EventLog): import("./types.js").AttributeSummary[];
    /** Get case attributes with statistics. */
    getCaseAttributes(log: EventLog): import("./types.js").AttributeSummary[];
    /** Get performance statistics for an event log. */
    getPerformanceStats(log: EventLog): import("./types.js").PerformanceStats;
    /** Get average case arrival rate (cases per hour). */
    getCaseArrivalAverage(log: EventLog): number;
    /**
     * Discover a Directly-Follows Graph from an event log.
     *
     * Mirrors `pm4py.discover_dfg()`.
     */
    discoverDFG(log: EventLog): import("./types.js").DFGResult;
    /**
     * Serialize a DFG result to a canonical JSON string.
     *
     * Mirrors `pm4py.write_dfg()`.
     *
     * @param dfg - DFG result from discoverDFG()
     */
    writeDfg(dfg: import("./types.js").DFGResult): string;
    /**
     * Deserialize a DFG from a JSON string.
     *
     * Mirrors `pm4py.read_dfg()`.
     *
     * @param json - JSON string of DFG data
     */
    readDfg(json: string): import("./types.js").DFGResult;
    /**
     * Discover a performance DFG with duration annotations on edges.
     *
     * Mirrors `pm4py.discover_performance_dfg()`.
     */
    discoverPerformanceDFG(log: EventLog): import("./types.js").PerformanceDFGResult;
    /**
     * Discover an eventually-follows graph (all activity pairs in any trace).
     *
     * Mirrors `pm4py.discover_eventually_follows_graph()`.
     */
    discoverEventuallyFollowsGraph(log: EventLog): import("./types.js").DFGEdge[];
    /**
     * Discover a process tree using the inductive miner.
     *
     * Mirrors `pm4py.discover_process_tree_inductive()`.
     */
    discoverProcessTree(log: EventLog): import("./types.js").ProcessTree;
    /**
     * Discover a Petri net from an event log using the inductive miner.
     *
     * Mirrors `pm4py.discover_petri_net_inductive()`.
     */
    discoverPetriNet(log: EventLog): import("./types.js").PetriNetResult;
    /**
     * Discover a BPMN model directly from an event log using the inductive miner.
     *
     * Combines inductive miner discovery with BPMN conversion in a single call.
     * Returns a complete BPMN 2.0 XML document importable by Camunda, Signavio, bpmn.io.
     *
     * Mirrors `pm4py.discover_bpmn_inductive()`.
     *
     * @example
     * ```ts
     * const log = powl.parseCsv("case_id,activity\n1,A\n1,B\n");
     * const bpmnXml = powl.discoverBpmn(log);
     * console.log(bpmnXml); // Complete BPMN 2.0 XML document
     * ```
     */
    discoverBpmn(log: EventLog): string;
    /**
     * Filter traces to only those starting with one of the given activities.
     *
     * Mirrors `pm4py.filter_start_activities()`.
     */
    filterStartActivities(log: EventLog, activities: string[]): EventLog;
    /**
     * Filter traces to only those ending with one of the given activities.
     *
     * Mirrors `pm4py.filter_end_activities()`.
     */
    filterEndActivities(log: EventLog, activities: string[]): EventLog;
    /**
     * Filter to keep only the top-k most frequent variants.
     *
     * Mirrors `pm4py.filter_variants_top_k()`.
     */
    filterVariantsTopK(log: EventLog, k: number): EventLog;
    /**
     * Filter traces by time range (Unix milliseconds).
     *
     * Mirrors `pm4py.filter_time_range()`.
     */
    filterTimeRange(log: EventLog, startMs: number, endMs: number): EventLog;
    /**
     * Compute the behavioural footprints of a POWL model.
     *
     * Returns start/end activities, sequence/parallel pairs, etc.
     */
    footprints(model: PowlModel): ModelFootprints;
    /**
     * Compute footprints-based conformance between an event log and a POWL model string.
     *
     * Returns fitness, precision, recall, f1.
     */
    conformanceFootprints(log: EventLog, modelStr: string): FootprintsConformanceResult;
    /**
     * Check whether a Petri net is sound (deadlock-free, bounded, liveness).
     */
    checkSoundness(pn: PetriNetResult): SoundnessResult;
    /**
     * Create a streaming conformance checker for real-time monitoring.
     *
     * Returns a handle for incremental trace processing with EWMA smoothing and drift detection.
     *
     * @param modelStr POWL model string representation.
     * @returns Handle ID for the streaming conformance checker.
     */
    streamingCreate(modelStr: string): number;
    /**
     * Push a trace to the streaming conformance checker.
     *
     * @param handle Handle ID from `streamingCreate()`.
     * @param traceJson JSON string of a Trace object (with case_id and events array).
     * @returns Current fitness and alerts as JSON object.
     */
    streamingPushTrace(handle: number, traceJson: string): StreamingConformanceSnapshot;
    /**
     * Get current snapshot of streaming conformance metrics.
     *
     * @param handle Handle ID from `streamingCreate()`.
     * @returns Current fitness, traces seen, windowed fitness, EWMA metrics, and drift signals.
     */
    streamingSnapshot(handle: number): StreamingConformanceSnapshot;
    /**
     * Discover a Petri net using the alpha miner.
     *
     * Mirrors `pm4py.discover_petri_net_alpha()`.
     */
    discoverPetriNetAlpha(log: EventLog): PetriNetResult;
    /**
     * Discover a Log Skeleton from an event log.
     *
     * Returns a model with six constraint types:
     * - equivalence: activities always co-occur with same frequency
     * - always_after: a always followed by b
     * - always_before: a always preceded by b
     * - never_together: a and b never in same trace
     * - directly_follows: a directly followed by b
     * - activ_freq: allowed activity frequencies per activity
     *
     * Mirrors `pm4py.discover_log_skeleton()`.
     *
     * @example
     * ```ts
     * const log = powl.parseXes("log.xes");
     * const skeleton = powl.discoverLogSkeleton(log);
     * console.log(skeleton.directly_follows); // [["A", "B"], ["B", "C"]]
     * ```
     */
    discoverLogSkeleton(log: EventLog): import("./types.js").LogSkeleton;
    /**
     * Discover a DECLARE model from an event log.
     *
     * Returns constraint templates with support/confidence metrics:
     * - response: if a occurs, b must occur after
     * - precedence: b only if a occurred before
     * - succession: response + precedence
     * - coexistence: a and b always together
     * - altresponse: each a has b before next a
     * - chainresponse: each a immediately followed by b
     *
     * Mirrors `pm4py.discover_declare()`.
     *
     * @example
     * ```ts
     * const log = powl.parseXes("log.xes");
     * const declare = powl.discoverDeclare(log);
     * console.log(declare.rules.response["A|B"]); // {support: 5, confidence: 4}
     * ```
     */
    discoverDeclare(log: EventLog): import("./types.js").DeclareModel;
    /**
     * Discover a temporal profile from an event log.
     *
     * Computes mean and standard deviation of elapsed time for each
     * directly-follows pair (A→B) in the log.
     *
     * Mirrors `pm4py.discover_temporal_profile()`.
     *
     * @example
     * ```ts
     * const log = powl.parseXes("log.xes");
     * const profile = powl.discoverTemporalProfile(log);
     * console.log(profile.pairs["A,B"]); // {mean_ms: 60000, stdev_ms: 5000, count: 10}
     * ```
     */
    discoverTemporalProfile(log: EventLog): import("./types.js").TemporalProfile;
    /**
     * Check temporal conformance between an event log and a temporal profile.
     *
     * Flags steps where |duration - mean| > zeta * stdev as deviations.
     *
     * @param log - Event log to check
     * @param profile - Temporal profile (from discoverTemporalProfile)
     * @param zeta - Number of standard deviations for threshold (typically 2.0)
     *
     * Mirrors `pm4py.check_temporal_conformance()`.
     *
     * @example
     * ```ts
     * const log = powl.parseXes("log.xes");
     * const profile = powl.discoverTemporalProfile(log);
     * const result = powl.checkTemporalConformance(log, profile, 2.0);
     * console.log(result.fitness); // 0.95
     * ```
     */
    checkTemporalConformance(log: EventLog, profile: import("./types.js").TemporalProfile, zeta: number): import("./types.js").TemporalConformance;
    /**
     * Discover a Heuristics Net from an event log.
     *
     * Uses dependency measure to filter causal relations. More lenient than
     * Alpha++ for handling noise and incomplete data.
     *
     * @param log - Event log to analyze
     * @param dependencyThreshold - Minimum dependency score (0.0 to 1.0, typically 0.5-0.9)
     *
     * Mirrors `pm4py.discover_heuristics_miner()`.
     *
     * @example
     * ```ts
     * const log = powl.parseXes("log.xes");
     * const net = powl.discoverHeuristicsMiner(log, 0.8);
     * console.log(net.dependencies); // [{from: "A", to: "B", dependency: 0.9, frequency: 5}]
     * ```
     */
    discoverHeuristicsMiner(log: EventLog, dependencyThreshold?: number): import("./types.js").HeuristicsNet;
    /**
     * Convert a Heuristics Net to a Petri Net.
     *
     * Creates places and transitions based on dependency relations.
     *
     * Mirrors `pm4py.heuristics_to_petri_net()`.
     *
     * @example
     * ```ts
     * const log = powl.parseXes("log.xes");
     * const net = powl.discoverHeuristicsMiner(log, 0.8);
     * const pn = powl.heuristicsToPetriNet(net);
     * console.log(pn.net.places); // Place objects
     * ```
     */
    heuristicsToPetriNet(net: import("./types.js").HeuristicsNet): import("./types.js").PetriNetResult;
    /**
     * Get all distinct values for a given event attribute with frequencies.
     *
     * Mirrors `pm4py.get_attribute_values()`.
     */
    getAttributeValues(log: EventLog, attributeKey: string): AttributeValue[];
    /**
     * Get case durations.
     *
     * Mirrors `pm4py.get_case_durations()`.
     */
    getCaseDurations(log: EventLog): CaseDurationResult[];
    /**
     * Get rework times (time between consecutive same-activity events in a case).
     */
    getReworkTimes(log: EventLog): ReworkTime[];
    /**
     * Filter traces by case size (number of events).
     * If maxSize is 0, only minSize is used as a lower bound.
     *
     * Mirrors `pm4py.filter_case_size()`.
     */
    filterCaseSize(log: EventLog, minSize: number, maxSize: number): EventLog;
    /**
     * Filter to keep only variants covering at least the given percentage.
     *
     * Mirrors `pm4py.filter_variants_reaching()`.
     */
    filterVariantsCoverage(log: EventLog, minCoverage: number): EventLog;
    /**
     * Serialize an event log to XES XML format.
     *
     * Mirrors `pm4py.write_xes()`.
     */
    writeXes(log: EventLog): string;
    /**
     * Serialize an event log to CSV format.
     *
     * Mirrors `pm4py.write_csv()`.
     */
    writeCsv(log: EventLog): string;
    /**
     * Get minimum self-distances for each activity.
     *
     * Mirrors `pm4py.get_minimum_self_distances()`.
     */
    getMinimumSelfDistances(log: EventLog): {
        activity: string;
        min_distance_ms: number;
    }[];
    /**
     * Get all case durations as a flat array of milliseconds.
     *
     * Mirrors `pm4py.get_all_case_durations()`.
     */
    getAllCaseDurations(log: EventLog): number[];
    /**
     * Get case overlap (fraction of shared prefixes between traces, 0.0–1.0).
     *
     * Mirrors `pm4py.get_case_overlap()`.
     */
    getCaseOverlap(log: EventLog): number;
    /**
     * Get all prefixes (partial traces) with their frequencies.
     *
     * Mirrors `pm4py.get_prefixes_from_log()`.
     */
    getPrefixes(log: EventLog): {
        prefix: string[];
        count: number;
        percentage: number;
    }[];
    /**
     * Get trace attribute values with frequencies.
     *
     * Mirrors `pm4py.get_trace_attribute_values()`.
     */
    getTraceAttributeValues(log: EventLog, attributeKey: string): AttributeValue[];
    /**
     * Get variants as tuples (activity sequences with count).
     *
     * Mirrors `pm4py.get_variants_as_tuples()`.
     */
    getVariantsAsTuples(log: EventLog): {
        activities: string[];
        count: number;
    }[];
    /**
     * Get variants with path durations (total, min, max, avg).
     *
     * Mirrors `pm4py.get_variants_paths_duration()`.
     */
    getVariantsPathsDuration(log: EventLog): {
        activities: string[];
        count: number;
        total_duration_ms: number;
        min_duration_ms: number;
        max_duration_ms: number;
        avg_duration_ms: number;
    }[];
    /**
     * Get cases per activity that show rework (activity appears more than once).
     *
     * Mirrors `pm4py.get_rework_cases_per_activity()`.
     */
    getReworkCasesPerActivity(log: EventLog): {
        activity: string;
        rework_cases: number;
        total_cases: number;
    }[];
    /**
     * Filter to keep only events between two activities (inclusive).
     *
     * Mirrors `pm4py.filter_between()`.
     */
    filterBetween(log: EventLog, act1: string, act2: string): EventLog;
    /**
     * Filter to keep only traces that start with the given prefix activities.
     *
     * Mirrors `pm4py.filter_prefixes()`.
     */
    filterPrefixes(log: EventLog, prefix: string[]): EventLog;
    /**
     * Filter to keep only traces that end with the given suffix activities.
     *
     * Mirrors `pm4py.filter_suffixes()`.
     */
    filterSuffixes(log: EventLog, suffix: string[]): EventLog;
    /**
     * Filter to keep only traces containing a directly-follows relation (a -> b).
     *
     * Mirrors `pm4py.filter_directly_follows_relation()`.
     */
    filterDirectlyFollows(log: EventLog, a: string, b: string): EventLog;
    /**
     * Filter to keep only traces containing a directly-follows relation (a → b).
     *
     * Mirrors `pm4py.filter_directly_follows_relation()`.
     *
     * @deprecated Use filterDirectlyFollows instead
     */
    filterEventuallyFollows(log: EventLog, a: string, b: string): EventLog;
    /**
     * Trim traces to remove events before the first start activity and after the last end activity.
     *
     * Mirrors `pm4py.filter_trim()`.
     */
    filterTrim(log: EventLog, startActivity: string, endActivity: string): EventLog;
    /**
     * Discover footprints directly from an event log.
     *
     * Mirrors `pm4py.discover_footprints()` applied to a log.
     */
    discoverLogFootprints(log: EventLog): {
        start_activities: string[];
        end_activities: string[];
        activities: string[];
        sequence: [string, string][];
        parallel: [string, string][];
    };
    /**
     * Sort an event log by case_id then timestamp.
     *
     * Mirrors `pm4py.sort_log()`.
     */
    sortLog(log: EventLog): EventLog;
    /**
     * Project an event log to keep only the specified attributes.
     *
     * Mirrors `pm4py.project_log()`.
     */
    projectLog(log: EventLog, attributes: string[]): EventLog;
    /**
     * Validate a POWL model string against structural soundness criteria.
     *
     * Uses POWLJudge to check for deadlock freedom, liveness, and boundedness.
     *
     * @returns Object with `verdict` (boolean), `reasoning` (string), and `violations` (array).
     */
    validatePowlStructure(modelStr: string): {
        verdict: boolean;
        reasoning: string;
        violations?: string[];
    };
    /**
     * Get few-shot demos for a specific domain.
     *
     * Returns a JSON array of few-shot examples for LLM-guided POWL generation.
     *
     * Supported domains: "loan_approval", "finance", "software_release", "it",
     * "devops", "ecommerce", "retail", "manufacturing", "production",
     * "healthcare", "medical".
     *
     * For unknown domains, returns general demos.
     */
    getDemosForDomain(domain: string): FewShotDemo[];
    /**
     * Generate executable code from a POWL model string.
     *
     * Converts POWL to n8n JSON, Temporal Go, Camunda BPMN, or YAWL v6 XML.
     *
     * @param modelStr POWL model string.
     * @param target One of: "n8n", "temporal", "camunda", "yawl".
     * @returns Object with `code` (string), `target` (string), and `format` (string).
     */
    generateCodeFromPowl(modelStr: string, target: "n8n" | "temporal" | "camunda" | "yawl"): {
        code: string;
        target: string;
        format: string;
    };
    /**
     * Complete NL → POWL → Code pipeline (hybrid: JS LLM API + WASM POWL operations).
     *
     * This is the main entry point for natural language workflow generation.
     * It:
     * 1. Calls an LLM (via JavaScript fetch) to convert NL to POWL
     * 2. Validates the POWL structure using WASM
     * 3. Refines if needed (calls LLM again with validation feedback)
     * 4. Returns the verified POWL model
     *
     * @param naturalLanguage Natural language description of the workflow.
     * @param llmConfig Optional LLM configuration (API endpoint, model, etc.).
     * @param domain Optional domain for few-shot demos.
     * @returns Parsed POWL model.
     */
    fromNaturalLanguage(naturalLanguage: string, llmConfig?: LLMConfig, domain?: string): Promise<PowlModel>;
    /**
     * Generate code from a natural language description.
     *
     * Combines `fromNaturalLanguage()` + `generateCodeFromPowl()`.
     *
     * @param naturalLanguage Natural language description.
     * @param target Code generation target ("n8n", "temporal", "camunda", "yawl").
     * @param llmConfig Optional LLM configuration.
     * @param domain Optional domain for few-shot demos.
     * @returns Generated code.
     */
    naturalLanguageToCode(naturalLanguage: string, target: "n8n" | "temporal" | "camunda" | "yawl", llmConfig?: LLMConfig, domain?: string): Promise<string>;
    private buildNLPrompt;
    private buildRefinementPrompt;
    private callLLMAPI;
    private getDefaultModel;
    private extractPowlFromResponse;
}
/**
 * Few-shot demo for LLM-guided POWL generation.
 */
export interface FewShotDemo {
    description: string;
    nl: string;
    powl: string;
}
/**
 * LLM configuration for natural language to POWL generation.
 *
 * Uses the Vercel AI SDK which supports multiple providers.
 */
export interface LLMConfig {
    /** LLM provider: "groq" (default), "openai", or "anthropic". */
    provider?: "groq" | "openai" | "anthropic";
    /** API key for the LLM service. */
    apiKey?: string;
    /** Model name (defaults depend on provider). */
    model?: string;
    /** Temperature for generation (default: 0.2). */
    temperature?: number;
    /** Maximum tokens (default: 1024). */
    maxTokens?: number;
}
//# sourceMappingURL=index.d.ts.map