import { G as GQPSchema } from './engine-Bg3M08x9.mjs';
export { C as CursorManager, a as GQP, b as GQPGraphCursor } from './engine-Bg3M08x9.mjs';
import { G as GQPAdapter, a as GQPPlugin, Q as QueryFilters, b as QueryOptions, c as QueryResult } from './types-CqJN-Ev5.mjs';
export { C as CostDirective, D as DEFAULT_LIMITS, d as DEFAULT_VALIDATION, e as DebugConfig, E as ExploreResult, F as FieldType, f as GQPAction, g as GQPCapability, h as GQPConfig, i as GQPCursor, j as GQPDirective, k as GQPEdge, l as GQPEngine, m as GQPField, n as GQPNode, o as IGQPSchema, I as IntrospectionMode, p as IntrospectionResult, L as LimitsConfig, N as NavigateResult, q as NeighborhoodView, r as NodeAccessRule, P as PluginContext, R as RLSFunction, s as RelationType, t as ResolveDirective, S as SchemaConfig, u as SearchDirective, v as SecurityConfig, w as SecurityContext, x as SecurityManager, T as TemporalDirective, y as ToolCallParams, z as ToolCallResult, V as ValidationConfig, A as Validator, B as createSecurityManager, H as createValidator, J as noopSecurityManager, K as safeJsonParse, M as safeJsonStringify } from './types-CqJN-Ev5.mjs';

/**
 * GQP Query Executor
 * Orchestrates query execution across adapters and plugins
 */

interface ExecutorConfig {
    defaultLimit: number;
    maxLimit: number;
    timeout: number;
    maxIncludeDepth?: number;
}
declare class QueryExecutor {
    private adapters;
    private plugins;
    private schema;
    private config;
    constructor(schema: GQPSchema, adapters: Map<string, GQPAdapter>, plugins: GQPPlugin[], config?: Partial<ExecutorConfig>);
    /**
     * Execute a query against a node
     */
    execute(nodeName: string, filters?: QueryFilters, options?: QueryOptions): Promise<QueryResult>;
    /**
     * Normalize and validate query options
     */
    private normalizeOptions;
    /**
     * Execute query with semantic search
     */
    executeWithSearch(nodeName: string, query: string, filters?: QueryFilters, options?: QueryOptions): Promise<QueryResult>;
    /**
     * Translate filter values using plugins
     */
    private translateFilters;
    /**
     * Execute with timeout
     */
    private executeWithTimeout;
    /**
     * Suggest next actions based on results
     */
    private suggestNextActions;
}

/**
 * GQP Error Classes
 * Environment-aware error handling with safe production messages
 */
/**
 * Error codes for GQP errors
 */
declare const GQPErrorCode: {
    readonly INVALID_ACTION: "INVALID_ACTION";
    readonly INVALID_NODE: "INVALID_NODE";
    readonly NODE_NOT_FOUND: "NODE_NOT_FOUND";
    readonly NODE_REQUIRED: "NODE_REQUIRED";
    readonly ADAPTER_NOT_FOUND: "ADAPTER_NOT_FOUND";
    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
    readonly AUTHORIZATION_ERROR: "AUTHORIZATION_ERROR";
    readonly ACCESS_DENIED: "ACCESS_DENIED";
    readonly INTROSPECTION_DISABLED: "INTROSPECTION_DISABLED";
    readonly QUERY_ERROR: "QUERY_ERROR";
    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
    readonly CONFIGURATION_ERROR: "CONFIGURATION_ERROR";
    readonly CURSOR_NOT_FOUND: "CURSOR_NOT_FOUND";
    readonly CURSOR_EXPIRED: "CURSOR_EXPIRED";
    readonly RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR";
    readonly PARSE_ERROR: "PARSE_ERROR";
    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
};
type GQPErrorCodeType = (typeof GQPErrorCode)[keyof typeof GQPErrorCode];
/**
 * GQP Error class with environment-aware message exposure
 */
declare class GQPError extends Error {
    readonly code: GQPErrorCodeType;
    readonly details?: unknown;
    readonly statusCode: number;
    constructor(code: GQPErrorCodeType, devMessage: string, details?: unknown, statusCode?: number);
    toJSON(): {
        code: GQPErrorCodeType;
        message: string;
        details?: unknown;
    };
}
/**
 * Create a GQP error with common patterns
 */
declare const createError: {
    invalidAction: (action: string) => GQPError;
    invalidNode: (node: string, pattern?: string) => GQPError;
    nodeNotFound: (node: string, suggestions?: string[]) => GQPError;
    nodeRequired: (action: string) => GQPError;
    adapterNotFound: (node: string) => GQPError;
    validation: (field: string, message: string, value?: unknown) => GQPError;
    accessDenied: (node: string, action?: string) => GQPError;
    introspectionDisabled: () => GQPError;
    timeout: (operation: string, timeoutMs: number) => GQPError;
    cursorNotFound: (cursorId: string) => GQPError;
    cursorExpired: (cursorId: string) => GQPError;
    parseError: (input: string, error?: string) => GQPError;
    rateLimit: (limit: number, windowMs: number) => GQPError;
    internal: (cause?: unknown) => GQPError;
};
/**
 * Check if an error is a GQP error
 */
declare function isGQPError(error: unknown): error is GQPError;
/**
 * Wrap any error as a GQP error
 */
declare function wrapError(error: unknown): GQPError;

export { type ExecutorConfig, GQPAdapter, GQPError, GQPErrorCode, type GQPErrorCodeType, GQPPlugin, GQPSchema, QueryExecutor, QueryFilters, QueryOptions, QueryResult, createError, isGQPError, wrapError };