import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
import { ToolBase } from "../../../shared/index.js";
import { z } from "zod";
declare const paramsSchema: z.ZodObject<{
    realmUid: z.ZodString;
    originationUid: z.ZodString;
    rules: z.ZodArray<z.ZodObject<{
        target: z.ZodObject<{
            identifier: z.ZodString;
            type: z.ZodEnum<{
                task: "task";
                step: "step";
                question: "question";
            }>;
            action: z.ZodEnum<{
                show: "show";
                hide: "hide";
            }>;
        }, z.core.$strip>;
        conditions: z.ZodUnion<readonly [z.ZodObject<{
            and: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                identifier: z.ZodString;
                operator: z.ZodEnum<{
                    eq: "eq";
                    neq: "neq";
                    gt: "gt";
                    gte: "gte";
                    lt: "lt";
                    lte: "lte";
                    contains: "contains";
                    not_contains: "not_contains";
                }>;
                operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                subtype: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>, z.ZodObject<{
                and: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                    identifier: z.ZodString;
                    operator: z.ZodEnum<{
                        eq: "eq";
                        neq: "neq";
                        gt: "gt";
                        gte: "gte";
                        lt: "lt";
                        lte: "lte";
                        contains: "contains";
                        not_contains: "not_contains";
                    }>;
                    operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                    subtype: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>, z.ZodObject<{
                    and: z.ZodArray<z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                }, z.core.$strip>, z.ZodObject<{
                    or: z.ZodArray<z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                }, z.core.$strip>]>>;
            }, z.core.$strip>, z.ZodObject<{
                or: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                    identifier: z.ZodString;
                    operator: z.ZodEnum<{
                        eq: "eq";
                        neq: "neq";
                        gt: "gt";
                        gte: "gte";
                        lt: "lt";
                        lte: "lte";
                        contains: "contains";
                        not_contains: "not_contains";
                    }>;
                    operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                    subtype: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>, z.ZodObject<{
                    and: z.ZodArray<z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                }, z.core.$strip>, z.ZodObject<{
                    or: z.ZodArray<z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                }, z.core.$strip>]>>;
            }, z.core.$strip>]>>;
        }, z.core.$strip>, z.ZodObject<{
            or: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                identifier: z.ZodString;
                operator: z.ZodEnum<{
                    eq: "eq";
                    neq: "neq";
                    gt: "gt";
                    gte: "gte";
                    lt: "lt";
                    lte: "lte";
                    contains: "contains";
                    not_contains: "not_contains";
                }>;
                operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                subtype: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>, z.ZodObject<{
                and: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                    identifier: z.ZodString;
                    operator: z.ZodEnum<{
                        eq: "eq";
                        neq: "neq";
                        gt: "gt";
                        gte: "gte";
                        lt: "lt";
                        lte: "lte";
                        contains: "contains";
                        not_contains: "not_contains";
                    }>;
                    operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                    subtype: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>, z.ZodObject<{
                    and: z.ZodArray<z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                }, z.core.$strip>, z.ZodObject<{
                    or: z.ZodArray<z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                }, z.core.$strip>]>>;
            }, z.core.$strip>, z.ZodObject<{
                or: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                    identifier: z.ZodString;
                    operator: z.ZodEnum<{
                        eq: "eq";
                        neq: "neq";
                        gt: "gt";
                        gte: "gte";
                        lt: "lt";
                        lte: "lte";
                        contains: "contains";
                        not_contains: "not_contains";
                    }>;
                    operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                    subtype: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>, z.ZodObject<{
                    and: z.ZodArray<z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                }, z.core.$strip>, z.ZodObject<{
                    or: z.ZodArray<z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                }, z.core.$strip>]>>;
            }, z.core.$strip>]>>;
        }, z.core.$strip>]>;
    }, z.core.$strip>>;
    strategy: z.ZodDefault<z.ZodEnum<{
        replace: "replace";
        merge: "merge";
    }>>;
}, z.core.$strip>;
export type ParamsSchema = z.infer<typeof paramsSchema>;
declare class RulesManageTool extends ToolBase<ParamsSchema> {
    protected config: {
        name: string;
        description: string;
        annotations: {
            title: string;
            readOnlyHint: boolean;
            idempotentHint: boolean;
            destructiveHint: boolean;
        };
    };
    protected getParamsSchema(): z.ZodObject<{
        realmUid: z.ZodString;
        originationUid: z.ZodString;
        rules: z.ZodArray<z.ZodObject<{
            target: z.ZodObject<{
                identifier: z.ZodString;
                type: z.ZodEnum<{
                    task: "task";
                    step: "step";
                    question: "question";
                }>;
                action: z.ZodEnum<{
                    show: "show";
                    hide: "hide";
                }>;
            }, z.core.$strip>;
            conditions: z.ZodUnion<readonly [z.ZodObject<{
                and: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                    identifier: z.ZodString;
                    operator: z.ZodEnum<{
                        eq: "eq";
                        neq: "neq";
                        gt: "gt";
                        gte: "gte";
                        lt: "lt";
                        lte: "lte";
                        contains: "contains";
                        not_contains: "not_contains";
                    }>;
                    operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                    subtype: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>, z.ZodObject<{
                    and: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>, z.ZodObject<{
                        and: z.ZodArray<z.ZodObject<{
                            identifier: z.ZodString;
                            operator: z.ZodEnum<{
                                eq: "eq";
                                neq: "neq";
                                gt: "gt";
                                gte: "gte";
                                lt: "lt";
                                lte: "lte";
                                contains: "contains";
                                not_contains: "not_contains";
                            }>;
                            operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                            subtype: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                    }, z.core.$strip>, z.ZodObject<{
                        or: z.ZodArray<z.ZodObject<{
                            identifier: z.ZodString;
                            operator: z.ZodEnum<{
                                eq: "eq";
                                neq: "neq";
                                gt: "gt";
                                gte: "gte";
                                lt: "lt";
                                lte: "lte";
                                contains: "contains";
                                not_contains: "not_contains";
                            }>;
                            operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                            subtype: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                    }, z.core.$strip>]>>;
                }, z.core.$strip>, z.ZodObject<{
                    or: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>, z.ZodObject<{
                        and: z.ZodArray<z.ZodObject<{
                            identifier: z.ZodString;
                            operator: z.ZodEnum<{
                                eq: "eq";
                                neq: "neq";
                                gt: "gt";
                                gte: "gte";
                                lt: "lt";
                                lte: "lte";
                                contains: "contains";
                                not_contains: "not_contains";
                            }>;
                            operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                            subtype: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                    }, z.core.$strip>, z.ZodObject<{
                        or: z.ZodArray<z.ZodObject<{
                            identifier: z.ZodString;
                            operator: z.ZodEnum<{
                                eq: "eq";
                                neq: "neq";
                                gt: "gt";
                                gte: "gte";
                                lt: "lt";
                                lte: "lte";
                                contains: "contains";
                                not_contains: "not_contains";
                            }>;
                            operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                            subtype: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                    }, z.core.$strip>]>>;
                }, z.core.$strip>]>>;
            }, z.core.$strip>, z.ZodObject<{
                or: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                    identifier: z.ZodString;
                    operator: z.ZodEnum<{
                        eq: "eq";
                        neq: "neq";
                        gt: "gt";
                        gte: "gte";
                        lt: "lt";
                        lte: "lte";
                        contains: "contains";
                        not_contains: "not_contains";
                    }>;
                    operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                    subtype: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>, z.ZodObject<{
                    and: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>, z.ZodObject<{
                        and: z.ZodArray<z.ZodObject<{
                            identifier: z.ZodString;
                            operator: z.ZodEnum<{
                                eq: "eq";
                                neq: "neq";
                                gt: "gt";
                                gte: "gte";
                                lt: "lt";
                                lte: "lte";
                                contains: "contains";
                                not_contains: "not_contains";
                            }>;
                            operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                            subtype: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                    }, z.core.$strip>, z.ZodObject<{
                        or: z.ZodArray<z.ZodObject<{
                            identifier: z.ZodString;
                            operator: z.ZodEnum<{
                                eq: "eq";
                                neq: "neq";
                                gt: "gt";
                                gte: "gte";
                                lt: "lt";
                                lte: "lte";
                                contains: "contains";
                                not_contains: "not_contains";
                            }>;
                            operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                            subtype: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                    }, z.core.$strip>]>>;
                }, z.core.$strip>, z.ZodObject<{
                    or: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                        identifier: z.ZodString;
                        operator: z.ZodEnum<{
                            eq: "eq";
                            neq: "neq";
                            gt: "gt";
                            gte: "gte";
                            lt: "lt";
                            lte: "lte";
                            contains: "contains";
                            not_contains: "not_contains";
                        }>;
                        operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                        subtype: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>, z.ZodObject<{
                        and: z.ZodArray<z.ZodObject<{
                            identifier: z.ZodString;
                            operator: z.ZodEnum<{
                                eq: "eq";
                                neq: "neq";
                                gt: "gt";
                                gte: "gte";
                                lt: "lt";
                                lte: "lte";
                                contains: "contains";
                                not_contains: "not_contains";
                            }>;
                            operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                            subtype: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                    }, z.core.$strip>, z.ZodObject<{
                        or: z.ZodArray<z.ZodObject<{
                            identifier: z.ZodString;
                            operator: z.ZodEnum<{
                                eq: "eq";
                                neq: "neq";
                                gt: "gt";
                                gte: "gte";
                                lt: "lt";
                                lte: "lte";
                                contains: "contains";
                                not_contains: "not_contains";
                            }>;
                            operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
                            subtype: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                    }, z.core.$strip>]>>;
                }, z.core.$strip>]>>;
            }, z.core.$strip>]>;
        }, z.core.$strip>>;
        strategy: z.ZodDefault<z.ZodEnum<{
            replace: "replace";
            merge: "merge";
        }>>;
    }, z.core.$strip>;
    protected getOutputSchema(): z.ZodObject<{
        originationId: z.ZodOptional<z.ZodNumber>;
        originationUid: z.ZodOptional<z.ZodString>;
        rulesCount: z.ZodOptional<z.ZodNumber>;
        strategy: z.ZodOptional<z.ZodString>;
        rules: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$loose>>>;
    }, z.core.$strip>;
    protected execute(params: ParamsSchema): Promise<CallToolResult>;
    /**
     * Resolve a rule's identifiers to UUIDs
     */
    private resolveRule;
    /**
     * Resolve conditions recursively (handles AND/OR groups)
     */
    private resolveConditions;
    /**
     * Count total conditions (including nested)
     */
    private countConditions;
}
export declare const RulesManage: RulesManageTool;
export {};
//# sourceMappingURL=RulesManage.d.ts.map