@wispbit/local 1.0.25

package/dist/src/schemas.d.ts

@@ -0,0 +1,1771 @@
+import { z } from "zod";
+import { Language } from "powerlint/languages";
+export declare const RangePositionSchema: z.ZodObject<{
+    line: z.ZodNumber;
+    column: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    line: number;
+    column?: number | undefined;
+}, {
+    line: number;
+    column?: number | undefined;
+}>;
+export declare const RangeObjectSchema: z.ZodObject<{
+    start: z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        line: number;
+        column?: number | undefined;
+    }, {
+        line: number;
+        column?: number | undefined;
+    }>;
+    end: z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        line: number;
+        column?: number | undefined;
+    }, {
+        line: number;
+        column?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    end: {
+        line: number;
+        column?: number | undefined;
+    };
+    start: {
+        line: number;
+        column?: number | undefined;
+    };
+}, {
+    end: {
+        line: number;
+        column?: number | undefined;
+    };
+    start: {
+        line: number;
+        column?: number | undefined;
+    };
+}>;
+export declare const PatternObjectSchema: z.ZodObject<{
+    selector: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodString>;
+    strictness: z.ZodOptional<z.ZodEnum<["cst", "smart", "ast", "relaxed", "signature"]>>;
+}, "strip", z.ZodTypeAny, {
+    selector?: string | undefined;
+    context?: string | undefined;
+    strictness?: "cst" | "smart" | "ast" | "relaxed" | "signature" | undefined;
+}, {
+    selector?: string | undefined;
+    context?: string | undefined;
+    strictness?: "cst" | "smart" | "ast" | "relaxed" | "signature" | undefined;
+}>;
+export declare const NthChildSchema: z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodObject<{
+    position: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+    reverse: z.ZodOptional<z.ZodBoolean>;
+    ofRule: z.ZodOptional<z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>>;
+}, "strip", z.ZodTypeAny, {
+    position: string | number;
+    reverse?: boolean | undefined;
+    ofRule?: any;
+}, {
+    position: string | number;
+    reverse?: boolean | undefined;
+    ofRule?: any;
+}>]>;
+export declare const AstGrepRuleSchema: z.ZodType<any>;
+export declare const FactPredicateSchema: z.ZodObject<{
+    fact: z.ZodEnum<["fs.siblingAny", "fs.siblingExists", "fs.pathMatches", "fs.ancestorHas"]>;
+    args: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    equals: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    equals: boolean;
+    fact: "fs.siblingAny" | "fs.siblingExists" | "fs.pathMatches" | "fs.ancestorHas";
+    args?: string | number | boolean | unknown[] | Record<string, unknown> | null | undefined;
+}, {
+    fact: "fs.siblingAny" | "fs.siblingExists" | "fs.pathMatches" | "fs.ancestorHas";
+    equals?: boolean | undefined;
+    args?: string | number | boolean | unknown[] | Record<string, unknown> | null | undefined;
+}>;
+export declare const WhereExprSchema: z.ZodType<any>;
+export declare const FileFilterConditionSchema: z.ZodUnion<[z.ZodObject<{
+    "fs.siblingExists": z.ZodObject<{
+        filename: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        filename: string;
+    }, {
+        filename: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    "fs.siblingExists": {
+        filename: string;
+    };
+}, {
+    "fs.siblingExists": {
+        filename: string;
+    };
+}>, z.ZodObject<{
+    "fs.pathMatches": z.ZodObject<{
+        pattern: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        pattern: string;
+    }, {
+        pattern: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    "fs.pathMatches": {
+        pattern: string;
+    };
+}, {
+    "fs.pathMatches": {
+        pattern: string;
+    };
+}>, z.ZodObject<{
+    "fs.ancestorHas": z.ZodObject<{
+        filename: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        filename: string;
+    }, {
+        filename: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    "fs.ancestorHas": {
+        filename: string;
+    };
+}, {
+    "fs.ancestorHas": {
+        filename: string;
+    };
+}>, z.ZodObject<{
+    "fs.siblingAny": z.ZodObject<{
+        pattern: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        pattern: string;
+    }, {
+        pattern: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    "fs.siblingAny": {
+        pattern: string;
+    };
+}, {
+    "fs.siblingAny": {
+        pattern: string;
+    };
+}>]>;
+export declare const FileFilterConditionsSchema: z.ZodObject<{
+    all: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        "fs.siblingExists": z.ZodObject<{
+            filename: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            filename: string;
+        }, {
+            filename: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.siblingExists": {
+            filename: string;
+        };
+    }, {
+        "fs.siblingExists": {
+            filename: string;
+        };
+    }>, z.ZodObject<{
+        "fs.pathMatches": z.ZodObject<{
+            pattern: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            pattern: string;
+        }, {
+            pattern: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    }, {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    }>, z.ZodObject<{
+        "fs.ancestorHas": z.ZodObject<{
+            filename: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            filename: string;
+        }, {
+            filename: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    }, {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    }>, z.ZodObject<{
+        "fs.siblingAny": z.ZodObject<{
+            pattern: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            pattern: string;
+        }, {
+            pattern: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    }, {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    }>]>, "many">>;
+    any: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        "fs.siblingExists": z.ZodObject<{
+            filename: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            filename: string;
+        }, {
+            filename: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.siblingExists": {
+            filename: string;
+        };
+    }, {
+        "fs.siblingExists": {
+            filename: string;
+        };
+    }>, z.ZodObject<{
+        "fs.pathMatches": z.ZodObject<{
+            pattern: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            pattern: string;
+        }, {
+            pattern: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    }, {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    }>, z.ZodObject<{
+        "fs.ancestorHas": z.ZodObject<{
+            filename: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            filename: string;
+        }, {
+            filename: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    }, {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    }>, z.ZodObject<{
+        "fs.siblingAny": z.ZodObject<{
+            pattern: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            pattern: string;
+        }, {
+            pattern: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    }, {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    }>]>, "many">>;
+    not: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        "fs.siblingExists": z.ZodObject<{
+            filename: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            filename: string;
+        }, {
+            filename: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.siblingExists": {
+            filename: string;
+        };
+    }, {
+        "fs.siblingExists": {
+            filename: string;
+        };
+    }>, z.ZodObject<{
+        "fs.pathMatches": z.ZodObject<{
+            pattern: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            pattern: string;
+        }, {
+            pattern: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    }, {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    }>, z.ZodObject<{
+        "fs.ancestorHas": z.ZodObject<{
+            filename: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            filename: string;
+        }, {
+            filename: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    }, {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    }>, z.ZodObject<{
+        "fs.siblingAny": z.ZodObject<{
+            pattern: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            pattern: string;
+        }, {
+            pattern: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    }, {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    }>]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    all?: ({
+        "fs.siblingExists": {
+            filename: string;
+        };
+    } | {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    } | {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    } | {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    })[] | undefined;
+    any?: ({
+        "fs.siblingExists": {
+            filename: string;
+        };
+    } | {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    } | {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    } | {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    })[] | undefined;
+    not?: ({
+        "fs.siblingExists": {
+            filename: string;
+        };
+    } | {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    } | {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    } | {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    })[] | undefined;
+}, {
+    all?: ({
+        "fs.siblingExists": {
+            filename: string;
+        };
+    } | {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    } | {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    } | {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    })[] | undefined;
+    any?: ({
+        "fs.siblingExists": {
+            filename: string;
+        };
+    } | {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    } | {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    } | {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    })[] | undefined;
+    not?: ({
+        "fs.siblingExists": {
+            filename: string;
+        };
+    } | {
+        "fs.pathMatches": {
+            pattern: string;
+        };
+    } | {
+        "fs.ancestorHas": {
+            filename: string;
+        };
+    } | {
+        "fs.siblingAny": {
+            pattern: string;
+        };
+    })[] | undefined;
+}>;
+export declare const AstGrepStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ast-grep">;
+    language: z.ZodNativeEnum<typeof Language>;
+    rule: z.ZodType<any, z.ZodTypeDef, any>;
+    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<any, z.ZodTypeDef, any>>>;
+}, "strict", z.ZodTypeAny, {
+    language: Language;
+    type: "ast-grep";
+    rule?: any;
+    constraints?: Record<string, any> | undefined;
+}, {
+    language: Language;
+    type: "ast-grep";
+    rule?: any;
+    constraints?: Record<string, any> | undefined;
+}>;
+export declare const FileFilterStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"file-filter">;
+    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ignore: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    conditions: z.ZodOptional<z.ZodObject<{
+        all: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            "fs.siblingExists": z.ZodObject<{
+                filename: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                filename: string;
+            }, {
+                filename: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.siblingExists": {
+                filename: string;
+            };
+        }, {
+            "fs.siblingExists": {
+                filename: string;
+            };
+        }>, z.ZodObject<{
+            "fs.pathMatches": z.ZodObject<{
+                pattern: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                pattern: string;
+            }, {
+                pattern: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        }, {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        }>, z.ZodObject<{
+            "fs.ancestorHas": z.ZodObject<{
+                filename: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                filename: string;
+            }, {
+                filename: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        }, {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        }>, z.ZodObject<{
+            "fs.siblingAny": z.ZodObject<{
+                pattern: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                pattern: string;
+            }, {
+                pattern: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        }, {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        }>]>, "many">>;
+        any: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            "fs.siblingExists": z.ZodObject<{
+                filename: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                filename: string;
+            }, {
+                filename: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.siblingExists": {
+                filename: string;
+            };
+        }, {
+            "fs.siblingExists": {
+                filename: string;
+            };
+        }>, z.ZodObject<{
+            "fs.pathMatches": z.ZodObject<{
+                pattern: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                pattern: string;
+            }, {
+                pattern: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        }, {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        }>, z.ZodObject<{
+            "fs.ancestorHas": z.ZodObject<{
+                filename: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                filename: string;
+            }, {
+                filename: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        }, {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        }>, z.ZodObject<{
+            "fs.siblingAny": z.ZodObject<{
+                pattern: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                pattern: string;
+            }, {
+                pattern: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        }, {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        }>]>, "many">>;
+        not: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            "fs.siblingExists": z.ZodObject<{
+                filename: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                filename: string;
+            }, {
+                filename: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.siblingExists": {
+                filename: string;
+            };
+        }, {
+            "fs.siblingExists": {
+                filename: string;
+            };
+        }>, z.ZodObject<{
+            "fs.pathMatches": z.ZodObject<{
+                pattern: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                pattern: string;
+            }, {
+                pattern: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        }, {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        }>, z.ZodObject<{
+            "fs.ancestorHas": z.ZodObject<{
+                filename: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                filename: string;
+            }, {
+                filename: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        }, {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        }>, z.ZodObject<{
+            "fs.siblingAny": z.ZodObject<{
+                pattern: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                pattern: string;
+            }, {
+                pattern: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        }, {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        }>]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        all?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+        any?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+        not?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+    }, {
+        all?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+        any?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+        not?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    type: "file-filter";
+    ignore?: string[] | undefined;
+    include?: string[] | undefined;
+    conditions?: {
+        all?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+        any?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+        not?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+    } | undefined;
+}, {
+    type: "file-filter";
+    ignore?: string[] | undefined;
+    include?: string[] | undefined;
+    conditions?: {
+        all?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+        any?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+        not?: ({
+            "fs.siblingExists": {
+                filename: string;
+            };
+        } | {
+            "fs.pathMatches": {
+                pattern: string;
+            };
+        } | {
+            "fs.ancestorHas": {
+                filename: string;
+            };
+        } | {
+            "fs.siblingAny": {
+                pattern: string;
+            };
+        })[] | undefined;
+    } | undefined;
+}>;
+export declare const LLMStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"llm">;
+}, "strict", z.ZodTypeAny, {
+    type: "llm";
+}, {
+    type: "llm";
+}>;
+export declare const GotoDefinitionStepSchema: z.ZodLazy<z.ZodObject<{
+    type: z.ZodLiteral<"goto-definition">;
+    language: z.ZodNativeEnum<typeof Language>;
+    where: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+}, "strict", z.ZodTypeAny, {
+    language: Language;
+    type: "goto-definition";
+    where?: any;
+}, {
+    language: Language;
+    type: "goto-definition";
+    where?: any;
+}>>;
+export declare const StepGroupStepSchema: z.ZodLazy<z.ZodObject<{
+    type: z.ZodLiteral<"step-group">;
+    steps: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"ast-grep">;
+        language: z.ZodNativeEnum<typeof Language>;
+        rule: z.ZodType<any, z.ZodTypeDef, any>;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<any, z.ZodTypeDef, any>>>;
+    }, "strict", z.ZodTypeAny, {
+        language: Language;
+        type: "ast-grep";
+        rule?: any;
+        constraints?: Record<string, any> | undefined;
+    }, {
+        language: Language;
+        type: "ast-grep";
+        rule?: any;
+        constraints?: Record<string, any> | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"file-filter">;
+        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        ignore: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        conditions: z.ZodOptional<z.ZodObject<{
+            all: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                "fs.siblingExists": z.ZodObject<{
+                    filename: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    filename: string;
+                }, {
+                    filename: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            }, {
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            }>, z.ZodObject<{
+                "fs.pathMatches": z.ZodObject<{
+                    pattern: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    pattern: string;
+                }, {
+                    pattern: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            }, {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            }>, z.ZodObject<{
+                "fs.ancestorHas": z.ZodObject<{
+                    filename: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    filename: string;
+                }, {
+                    filename: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            }, {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            }>, z.ZodObject<{
+                "fs.siblingAny": z.ZodObject<{
+                    pattern: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    pattern: string;
+                }, {
+                    pattern: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            }, {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            }>]>, "many">>;
+            any: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                "fs.siblingExists": z.ZodObject<{
+                    filename: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    filename: string;
+                }, {
+                    filename: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            }, {
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            }>, z.ZodObject<{
+                "fs.pathMatches": z.ZodObject<{
+                    pattern: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    pattern: string;
+                }, {
+                    pattern: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            }, {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            }>, z.ZodObject<{
+                "fs.ancestorHas": z.ZodObject<{
+                    filename: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    filename: string;
+                }, {
+                    filename: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            }, {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            }>, z.ZodObject<{
+                "fs.siblingAny": z.ZodObject<{
+                    pattern: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    pattern: string;
+                }, {
+                    pattern: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            }, {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            }>]>, "many">>;
+            not: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                "fs.siblingExists": z.ZodObject<{
+                    filename: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    filename: string;
+                }, {
+                    filename: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            }, {
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            }>, z.ZodObject<{
+                "fs.pathMatches": z.ZodObject<{
+                    pattern: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    pattern: string;
+                }, {
+                    pattern: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            }, {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            }>, z.ZodObject<{
+                "fs.ancestorHas": z.ZodObject<{
+                    filename: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    filename: string;
+                }, {
+                    filename: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            }, {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            }>, z.ZodObject<{
+                "fs.siblingAny": z.ZodObject<{
+                    pattern: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    pattern: string;
+                }, {
+                    pattern: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            }, {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            }>]>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            all?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            any?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            not?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+        }, {
+            all?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            any?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            not?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "file-filter";
+        ignore?: string[] | undefined;
+        include?: string[] | undefined;
+        conditions?: {
+            all?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            any?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            not?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+        } | undefined;
+    }, {
+        type: "file-filter";
+        ignore?: string[] | undefined;
+        include?: string[] | undefined;
+        conditions?: {
+            all?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            any?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            not?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"llm">;
+    }, "strict", z.ZodTypeAny, {
+        type: "llm";
+    }, {
+        type: "llm";
+    }>, z.ZodLazy<z.ZodObject<{
+        type: z.ZodLiteral<"goto-definition">;
+        language: z.ZodNativeEnum<typeof Language>;
+        where: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+    }, "strict", z.ZodTypeAny, {
+        language: Language;
+        type: "goto-definition";
+        where?: any;
+    }, {
+        language: Language;
+        type: "goto-definition";
+        where?: any;
+    }>>]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    type: "step-group";
+    steps: ({
+        language: Language;
+        type: "ast-grep";
+        rule?: any;
+        constraints?: Record<string, any> | undefined;
+    } | {
+        type: "file-filter";
+        ignore?: string[] | undefined;
+        include?: string[] | undefined;
+        conditions?: {
+            all?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            any?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            not?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+        } | undefined;
+    } | {
+        type: "llm";
+    } | {
+        language: Language;
+        type: "goto-definition";
+        where?: any;
+    })[];
+}, {
+    type: "step-group";
+    steps: ({
+        language: Language;
+        type: "ast-grep";
+        rule?: any;
+        constraints?: Record<string, any> | undefined;
+    } | {
+        type: "file-filter";
+        ignore?: string[] | undefined;
+        include?: string[] | undefined;
+        conditions?: {
+            all?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            any?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+            not?: ({
+                "fs.siblingExists": {
+                    filename: string;
+                };
+            } | {
+                "fs.pathMatches": {
+                    pattern: string;
+                };
+            } | {
+                "fs.ancestorHas": {
+                    filename: string;
+                };
+            } | {
+                "fs.siblingAny": {
+                    pattern: string;
+                };
+            })[] | undefined;
+        } | undefined;
+    } | {
+        type: "llm";
+    } | {
+        language: Language;
+        type: "goto-definition";
+        where?: any;
+    })[];
+}>>;
+export declare const RuleStepSchema: z.ZodType<any>;
+export declare const MatchRangeSchema: z.ZodObject<{
+    start: z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        line: number;
+        column: number;
+    }, {
+        line: number;
+        column: number;
+    }>;
+    end: z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        line: number;
+        column: number;
+    }, {
+        line: number;
+        column: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    end: {
+        line: number;
+        column: number;
+    };
+    start: {
+        line: number;
+        column: number;
+    };
+}, {
+    end: {
+        line: number;
+        column: number;
+    };
+    start: {
+        line: number;
+        column: number;
+    };
+}>;
+export declare const MatchSourceSchema: z.ZodType<any>;
+export declare const MatchMetadataSchema: z.ZodOptional<z.ZodObject<{
+    fromCache: z.ZodOptional<z.ZodBoolean>;
+    llmValidation: z.ZodOptional<z.ZodObject<{
+        isViolation: z.ZodBoolean;
+        confidence: z.ZodNumber;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        isViolation: boolean;
+        confidence: number;
+        reason: string;
+    }, {
+        isViolation: boolean;
+        confidence: number;
+        reason: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    fromCache?: boolean | undefined;
+    llmValidation?: {
+        isViolation: boolean;
+        confidence: number;
+        reason: string;
+    } | undefined;
+}, {
+    fromCache?: boolean | undefined;
+    llmValidation?: {
+        isViolation: boolean;
+        confidence: number;
+        reason: string;
+    } | undefined;
+}>>;
+export declare const MatchSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
+    range: z.ZodObject<{
+        start: z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            line: number;
+            column: number;
+        }, {
+            line: number;
+            column: number;
+        }>;
+        end: z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            line: number;
+            column: number;
+        }, {
+            line: number;
+            column: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        end: {
+            line: number;
+            column: number;
+        };
+        start: {
+            line: number;
+            column: number;
+        };
+    }, {
+        end: {
+            line: number;
+            column: number;
+        };
+        start: {
+            line: number;
+            column: number;
+        };
+    }>;
+    symbol: z.ZodOptional<z.ZodString>;
+    language: z.ZodNativeEnum<typeof Language>;
+    source: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        fromCache: z.ZodOptional<z.ZodBoolean>;
+        llmValidation: z.ZodOptional<z.ZodObject<{
+            isViolation: z.ZodBoolean;
+            confidence: z.ZodNumber;
+            reason: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            isViolation: boolean;
+            confidence: number;
+            reason: string;
+        }, {
+            isViolation: boolean;
+            confidence: number;
+            reason: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        fromCache?: boolean | undefined;
+        llmValidation?: {
+            isViolation: boolean;
+            confidence: number;
+            reason: string;
+        } | undefined;
+    }, {
+        fromCache?: boolean | undefined;
+        llmValidation?: {
+            isViolation: boolean;
+            confidence: number;
+            reason: string;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    language: Language;
+    filePath: string;
+    range: {
+        end: {
+            line: number;
+            column: number;
+        };
+        start: {
+            line: number;
+            column: number;
+        };
+    };
+    symbol?: string | undefined;
+    text?: string | undefined;
+    metadata?: {
+        fromCache?: boolean | undefined;
+        llmValidation?: {
+            isViolation: boolean;
+            confidence: number;
+            reason: string;
+        } | undefined;
+    } | undefined;
+    source?: any[] | undefined;
+}, {
+    language: Language;
+    filePath: string;
+    range: {
+        end: {
+            line: number;
+            column: number;
+        };
+        start: {
+            line: number;
+            column: number;
+        };
+    };
+    symbol?: string | undefined;
+    text?: string | undefined;
+    metadata?: {
+        fromCache?: boolean | undefined;
+        llmValidation?: {
+            isViolation: boolean;
+            confidence: number;
+            reason: string;
+        } | undefined;
+    } | undefined;
+    source?: any[] | undefined;
+}>;
+export declare const GenerateRuleSchema: z.ZodObject<{
+    reason: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        step: z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        step?: any;
+    }, {
+        id: string;
+        step?: any;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    reason: string;
+    steps: {
+        id: string;
+        step?: any;
+    }[];
+}, {
+    reason: string;
+    steps: {
+        id: string;
+        step?: any;
+    }[];
+}>;
+export declare const GenerateRuleSchemaTool: import("openai/lib/parser.mjs").AutoParseableTool<{
+    arguments: z.ZodObject<{
+        reason: z.ZodString;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            step: z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            step?: any;
+        }, {
+            id: string;
+            step?: any;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        reason: string;
+        steps: {
+            id: string;
+            step?: any;
+        }[];
+    }, {
+        reason: string;
+        steps: {
+            id: string;
+            step?: any;
+        }[];
+    }>;
+    name: string;
+    function: (args: {
+        reason: string;
+        steps: {
+            id: string;
+            step?: any;
+        }[];
+    }) => unknown;
+}>;
+//# sourceMappingURL=schemas.d.ts.map