/**
 * GQP Input Validation
 * Configurable validation with secure defaults
 */

/**
 * Validation configuration
 */
interface ValidationConfig {
    /** Enforce strict node name format (default: true) */
    strictNodeNames?: boolean;
    /** Custom node name pattern (default: /^[a-zA-Z_][a-zA-Z0-9_]*$/) */
    nodeNamePattern?: RegExp;
    /** Allowed filter operators */
    allowedFilterOperators?: string[];
    /** Max array size in filters */
    maxArrayInFilter?: number;
    /** Max filter depth */
    maxFilterDepth?: number;
    /** Max query string length */
    maxQueryLength?: number;
}
/**
 * Limits configuration
 */
interface LimitsConfig {
    /** Maximum limit for query results (default: 100) */
    maxLimit?: number;
    /** Default limit for query results (default: 10) */
    defaultLimit?: number;
    /** Maximum offset for pagination (default: 10000) */
    maxOffset?: number;
    /** Maximum include depth for relationships (default: 3) */
    maxIncludeDepth?: number;
    /** Maximum cursors to maintain (default: 100) */
    maxCursors?: number;
    /** Cursor TTL in milliseconds (default: 30 minutes) */
    cursorTTL?: number;
    /** Maximum cursor path length (default: 100) */
    maxCursorPathLength?: number;
    /** Query timeout in milliseconds (default: 30000) */
    timeout?: number;
}
/**
 * Default validation config
 */
declare const DEFAULT_VALIDATION: Required<ValidationConfig>;
/**
 * Default limits config
 */
declare const DEFAULT_LIMITS: Required<LimitsConfig>;
/**
 * Validation utilities
 */
declare class Validator {
    private config;
    private limits;
    constructor(validationConfig?: ValidationConfig, limitsConfig?: LimitsConfig);
    /**
     * Validate a node name
     */
    validateNodeName(node: unknown): string;
    /**
     * Validate action parameter
     */
    validateAction(action: unknown): "explore" | "navigate" | "query" | "introspect";
    /**
     * Validate and normalize query options
     */
    validateOptions(options?: QueryOptions): QueryOptions;
    /**
     * Validate query string
     */
    validateQuery(query: unknown): string | undefined;
    /**
     * Validate filters object
     */
    validateFilters(filters: unknown, depth?: number): QueryFilters;
    /**
     * Validate nested filter (operator object)
     */
    private validateNestedFilter;
    /**
     * Validate cursor ID format
     */
    validateCursorId(cursorId: unknown): string | undefined;
    /**
     * Validate complete tool call params
     */
    validateToolCallParams(params: unknown): ToolCallParams;
    /**
     * Get current limits
     */
    getLimits(): Required<LimitsConfig>;
    /**
     * Get current validation config
     */
    getConfig(): Required<ValidationConfig>;
}
/**
 * Create a validator instance
 */
declare function createValidator(validationConfig?: ValidationConfig, limitsConfig?: LimitsConfig): Validator;
/**
 * Safe JSON parse with error handling
 */
declare function safeJsonParse<T>(json: string, fallback?: T): T;
/**
 * Circular-safe JSON stringify
 */
declare function safeJsonStringify(obj: unknown, maxDepth?: number): string;

/**
 * GQP Security Layer
 * Optional authorization and row-level security
 */

/**
 * Security context provided by the application
 */
interface SecurityContext {
    /** User identifier */
    userId?: string;
    /** Organization/tenant identifier */
    orgId?: string;
    /** User roles */
    roles?: string[];
    /** Custom claims/attributes */
    claims?: Record<string, unknown>;
}
/**
 * Access rule for a node
 */
interface NodeAccessRule {
    /** Roles that can access this node (empty = all roles) */
    roles?: string[];
    /** Specific actions allowed (empty = all actions) */
    actions?: ("explore" | "navigate" | "query")[];
    /** Custom access check function */
    check?: (ctx: SecurityContext) => boolean | Promise<boolean>;
}
/**
 * Row-level security function
 * Returns filters to apply to queries on this node
 */
type RLSFunction = (ctx: SecurityContext) => QueryFilters | Promise<QueryFilters>;
/**
 * Introspection access mode
 */
type IntrospectionMode = "public" | "authenticated" | "disabled" | ((ctx: SecurityContext) => boolean);
/**
 * Security configuration
 */
interface SecurityConfig {
    /**
     * Context provider function
     * Called before each operation to get current security context
     */
    context?: () => SecurityContext | Promise<SecurityContext>;
    /**
     * Node-level access rules
     * Key is node name or '*' for default
     */
    nodeAccess?: Record<string, NodeAccessRule>;
    /**
     * Row-level security rules
     * Key is node name or '*' for default
     * Returns additional filters to apply to all queries
     */
    rowLevelSecurity?: Record<string, RLSFunction>;
    /**
     * Schema introspection access
     * - 'public': anyone can introspect
     * - 'authenticated': requires context.userId
     * - 'disabled': introspection throws error
     * - function: custom check
     */
    introspection?: IntrospectionMode;
    /**
     * Fields to hide from schema introspection
     * Supports wildcards: ['password', '*Token', 'secret*']
     */
    hiddenFields?: string[];
    /**
     * Nodes to hide from exploration
     * Still accessible if you know the name (use nodeAccess to fully block)
     */
    hiddenNodes?: string[];
}
/**
 * Security manager
 */
declare class SecurityManager {
    private config;
    private defaultContext;
    constructor(config?: SecurityConfig);
    /**
     * Check if security is enabled
     */
    isEnabled(): boolean;
    /**
     * Get current security context
     */
    getContext(): Promise<SecurityContext>;
    /**
     * Check if current context can access a node
     */
    checkNodeAccess(node: string, action: "explore" | "navigate" | "query", ctx?: SecurityContext): Promise<void>;
    /**
     * Get row-level security filters for a node
     */
    getRLSFilters(node: string, ctx?: SecurityContext): Promise<QueryFilters>;
    /**
     * Apply RLS filters to existing filters
     */
    applyRLS(node: string, filters: QueryFilters, ctx?: SecurityContext): Promise<QueryFilters>;
    /**
     * Check introspection access
     */
    checkIntrospectionAccess(ctx?: SecurityContext): Promise<void>;
    /**
     * Check if a field should be hidden from introspection
     */
    isFieldHidden(fieldName: string): boolean;
    /**
     * Check if a node should be hidden from exploration
     */
    isNodeHidden(nodeName: string): boolean;
    /**
     * Filter hidden fields from a node
     */
    filterHiddenFields(node: GQPNode): GQPNode;
    /**
     * Match a field name against a pattern (supports * wildcard)
     */
    private matchPattern;
    /**
     * Get security config
     */
    getConfig(): SecurityConfig;
}
/**
 * Create a security manager instance
 */
declare function createSecurityManager(config?: SecurityConfig): SecurityManager;
/**
 * No-op security manager (for when security is disabled)
 */
declare const noopSecurityManager: SecurityManager;

/**
 * GQP Core Types
 * Zero-dependency type definitions for the graph engine
 */
type FieldType = "String" | "Int" | "Float" | "Boolean" | "DateTime" | "Json" | "Enum" | "ID";
type RelationType = "belongsTo" | "hasOne" | "hasMany";
type GQPCapability = "fuzzy_search" | "full_text" | "temporal_filter" | "enum_filter" | "json_query";
type GQPAction = "explore" | "navigate" | "query" | "introspect";
interface GQPDirective {
    name: string;
    args: Record<string, unknown>;
}
interface SearchDirective extends GQPDirective {
    name: "@search";
    args: {
        type: "fuzzy" | "exact";
        threshold?: number;
    };
}
interface TemporalDirective extends GQPDirective {
    name: "@reasoning";
    args: {
        type: "temporal";
        format?: string;
    };
}
interface ResolveDirective extends GQPDirective {
    name: "@resolve";
    args: {
        source: string;
        endpoint: string;
        cache?: {
            ttl: number;
        };
    };
}
interface CostDirective extends GQPDirective {
    name: "@cost";
    args: {
        credits: number;
        rateLimit?: string;
    };
}
interface GQPField {
    name: string;
    type: FieldType;
    nullable: boolean;
    isList: boolean;
    description?: string;
    directives: GQPDirective[];
    enumValues?: string[];
}
interface GQPEdge {
    name: string;
    to: string;
    relation: RelationType;
    foreignKey?: string;
    description?: string;
}
interface GQPNode {
    name: string;
    description?: string;
    fields: GQPField[];
    edges: GQPEdge[];
    capabilities: GQPCapability[];
    source: string;
}
interface GQPCursor {
    id: string;
    currentNode: string | null;
    neighbors: string[];
    path: string[];
    depth: number;
    createdAt: number;
    metadata: {
        totalNodes: number;
        exploredNodes: number;
    };
}
interface NeighborhoodView {
    currentNode: GQPNode | null;
    neighbors: Array<{
        name: string;
        description?: string;
        relation: RelationType;
        distance: number;
    }>;
    path: string[];
    depth: number;
    availableActions: GQPAction[];
}
interface QueryFilters {
    [field: string]: unknown;
}
interface QueryOptions {
    limit?: number;
    offset?: number;
    orderBy?: {
        field: string;
        direction: "asc" | "desc";
    };
    include?: string[];
    cursor?: string;
}
interface QueryResult<T = unknown> {
    data: T[];
    meta: {
        total?: number;
        hasMore: boolean;
        executionTimeMs: number;
    };
    cursor?: GQPCursor;
    nextActions?: string[];
}
interface ToolCallParams {
    action: GQPAction;
    node?: string;
    query?: string;
    filters?: QueryFilters;
    options?: QueryOptions;
    cursorId?: string;
}
interface ExploreResult {
    availableNodes: Array<{
        name: string;
        description?: string;
        operations: string[];
    }>;
    message: string;
    totalNodes: number;
}
interface NavigateResult {
    currentNode: string;
    fields: Array<{
        name: string;
        type: FieldType;
        description?: string;
        capabilities: string[];
    }>;
    relatedNodes: Array<{
        name: string;
        relation: RelationType;
        description?: string;
    }>;
    capabilities: GQPCapability[];
    path: string[];
}
interface IntrospectionResult {
    nodes: GQPNode[];
    capabilities: GQPCapability[];
    version: string;
}
type ToolCallResult = ExploreResult | NavigateResult | QueryResult | IntrospectionResult;

/**
 * Schema configuration for introspection and visibility
 */
interface SchemaConfig {
    /** Fields to hide from schema introspection (supports wildcards) */
    hiddenFields?: string[];
    /** Nodes to hide from exploration */
    hiddenNodes?: string[];
    /** Refresh schema periodically (ms). 0 = never refresh */
    refreshInterval?: number;
}
/**
 * Debug configuration
 */
interface DebugConfig {
    /** Enable debug mode */
    enabled?: boolean;
    /** Log level */
    logLevel?: "silent" | "error" | "warn" | "info" | "verbose";
    /** Expose detailed error messages (overrides NODE_ENV detection) */
    exposeErrors?: boolean;
}
interface GQPConfig {
    /** Data source adapters */
    sources: Record<string, GQPAdapter>;
    /** Feature flags */
    features?: {
        fuzzySearch?: boolean;
        temporalReasoning?: boolean;
        neighborhoodSize?: number;
        maxDepth?: number;
    };
    /** Plugins */
    plugins?: GQPPlugin[];
    /** Directive overrides */
    directives?: {
        overrides?: Record<string, Partial<GQPField>>;
        defaults?: Record<string, unknown>;
    };
    /** Security configuration (optional - disable for internal tools/prototypes) */
    security?: SecurityConfig;
    /** Input validation configuration */
    validation?: ValidationConfig;
    /** Query and resource limits */
    limits?: LimitsConfig;
    /** Schema visibility configuration */
    schema?: SchemaConfig;
    /** Debug configuration */
    debug?: DebugConfig;
}
interface GQPAdapter {
    name: string;
    /**
     * Introspect data source and return schema nodes
     */
    introspect(): Promise<GQPNode[]>;
    /**
     * Execute a query against the data source
     */
    execute(nodeName: string, filters: QueryFilters, options: QueryOptions): Promise<unknown[]>;
    /**
     * Get count for pagination
     */
    count?(nodeName: string, filters: QueryFilters): Promise<number>;
}
interface GQPPlugin {
    name: string;
    /**
     * Called during initialization
     */
    onInit?(engine: GQPEngine): Promise<void>;
    /**
     * Called during cleanup/shutdown
     */
    onDestroy?(): Promise<void>;
    /**
     * Transform filters before query execution
     */
    onPreQuery?(node: GQPNode, filters: QueryFilters, context: PluginContext): Promise<QueryFilters>;
    /**
     * Post-process query results
     */
    onPostQuery?(node: GQPNode, results: unknown[], context: PluginContext): Promise<unknown[]>;
    /**
     * Translate a filter value (e.g., "last week" -> date range)
     */
    translateFilter?(field: GQPField, value: unknown, context: PluginContext): unknown | null;
}
interface PluginContext {
    query?: string;
    filters: QueryFilters;
    options: QueryOptions;
}
interface GQPEngine {
    getSchema(): GQPSchema;
    getAdapter(name: string): GQPAdapter | undefined;
    getPlugins(): GQPPlugin[];
}
interface GQPSchema {
    getNode(name: string): GQPNode | undefined;
    getRootNodes(): GQPNode[];
    getNeighbors(nodeName: string, limit?: number): GQPNode[];
    getAllNodes(): GQPNode[];
}

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