/**
 * Zod schemas for decision strategy validation.
 */
import { z } from 'zod';
export declare const PageUrlConditionZ: z.ZodObject<{
    type: z.ZodLiteral<"page_url">;
    url: z.ZodString;
}, "strip", z.ZodTypeAny, {
    url: string;
    type: "page_url";
}, {
    url: string;
    type: "page_url";
}>;
export declare const RouteConditionZ: z.ZodObject<{
    type: z.ZodLiteral<"route">;
    routeId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "route";
    routeId: string;
}, {
    type: "route";
    routeId: string;
}>;
export declare const AnchorVisibleConditionZ: z.ZodObject<{
    type: z.ZodLiteral<"anchor_visible">;
    anchorId: z.ZodString;
    state: z.ZodEnum<["visible", "present", "absent"]>;
}, "strip", z.ZodTypeAny, {
    anchorId: string;
    state: "visible" | "present" | "absent";
    type: "anchor_visible";
}, {
    anchorId: string;
    state: "visible" | "present" | "absent";
    type: "anchor_visible";
}>;
export declare const EventOccurredConditionZ: z.ZodObject<{
    type: z.ZodLiteral<"event_occurred">;
    eventName: z.ZodString;
    withinMs: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: "event_occurred";
    eventName: string;
    withinMs?: number | undefined;
}, {
    type: "event_occurred";
    eventName: string;
    withinMs?: number | undefined;
}>;
export declare const StateEqualsConditionZ: z.ZodObject<{
    type: z.ZodLiteral<"state_equals">;
    key: z.ZodString;
    value: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    type: "state_equals";
    key: string;
    value?: unknown;
}, {
    type: "state_equals";
    key: string;
    value?: unknown;
}>;
export declare const ViewportConditionZ: z.ZodObject<{
    type: z.ZodLiteral<"viewport">;
    minWidth: z.ZodOptional<z.ZodNumber>;
    maxWidth: z.ZodOptional<z.ZodNumber>;
    minHeight: z.ZodOptional<z.ZodNumber>;
    maxHeight: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: "viewport";
    minWidth?: number | undefined;
    maxWidth?: number | undefined;
    minHeight?: number | undefined;
    maxHeight?: number | undefined;
}, {
    type: "viewport";
    minWidth?: number | undefined;
    maxWidth?: number | undefined;
    minHeight?: number | undefined;
    maxHeight?: number | undefined;
}>;
export declare const SessionMetricConditionZ: z.ZodObject<{
    type: z.ZodLiteral<"session_metric">;
    key: z.ZodString;
    operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
    threshold: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "session_metric";
    key: string;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    threshold: number;
}, {
    type: "session_metric";
    key: string;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    threshold: number;
}>;
export declare const DismissedConditionZ: z.ZodObject<{
    type: z.ZodLiteral<"dismissed">;
    key: z.ZodString;
    inverted: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    type: "dismissed";
    key: string;
    inverted?: boolean | undefined;
}, {
    type: "dismissed";
    key: string;
    inverted?: boolean | undefined;
}>;
export declare const CooldownActiveConditionZ: z.ZodObject<{
    type: z.ZodLiteral<"cooldown_active">;
    key: z.ZodString;
    inverted: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    type: "cooldown_active";
    key: string;
    inverted?: boolean | undefined;
}, {
    type: "cooldown_active";
    key: string;
    inverted?: boolean | undefined;
}>;
export declare const FrequencyLimitConditionZ: z.ZodObject<{
    type: z.ZodLiteral<"frequency_limit">;
    key: z.ZodString;
    limit: z.ZodNumber;
    inverted: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    type: "frequency_limit";
    key: string;
    limit: number;
    inverted?: boolean | undefined;
}, {
    type: "frequency_limit";
    key: string;
    limit: number;
    inverted?: boolean | undefined;
}>;
export declare const EventCountConditionZ: z.ZodObject<{
    type: z.ZodLiteral<"event_count">;
    key: z.ZodString;
    operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
    count: z.ZodNumber;
    withinMs: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: "event_count";
    key: string;
    count: number;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    withinMs?: number | undefined;
}, {
    type: "event_count";
    key: string;
    count: number;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    withinMs?: number | undefined;
}>;
export declare const ConditionZ: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
    type: z.ZodLiteral<"page_url">;
    url: z.ZodString;
}, "strip", z.ZodTypeAny, {
    url: string;
    type: "page_url";
}, {
    url: string;
    type: "page_url";
}>, z.ZodObject<{
    type: z.ZodLiteral<"route">;
    routeId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "route";
    routeId: string;
}, {
    type: "route";
    routeId: string;
}>, z.ZodObject<{
    type: z.ZodLiteral<"anchor_visible">;
    anchorId: z.ZodString;
    state: z.ZodEnum<["visible", "present", "absent"]>;
}, "strip", z.ZodTypeAny, {
    anchorId: string;
    state: "visible" | "present" | "absent";
    type: "anchor_visible";
}, {
    anchorId: string;
    state: "visible" | "present" | "absent";
    type: "anchor_visible";
}>, z.ZodObject<{
    type: z.ZodLiteral<"event_occurred">;
    eventName: z.ZodString;
    withinMs: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: "event_occurred";
    eventName: string;
    withinMs?: number | undefined;
}, {
    type: "event_occurred";
    eventName: string;
    withinMs?: number | undefined;
}>, z.ZodObject<{
    type: z.ZodLiteral<"state_equals">;
    key: z.ZodString;
    value: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    type: "state_equals";
    key: string;
    value?: unknown;
}, {
    type: "state_equals";
    key: string;
    value?: unknown;
}>, z.ZodObject<{
    type: z.ZodLiteral<"viewport">;
    minWidth: z.ZodOptional<z.ZodNumber>;
    maxWidth: z.ZodOptional<z.ZodNumber>;
    minHeight: z.ZodOptional<z.ZodNumber>;
    maxHeight: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: "viewport";
    minWidth?: number | undefined;
    maxWidth?: number | undefined;
    minHeight?: number | undefined;
    maxHeight?: number | undefined;
}, {
    type: "viewport";
    minWidth?: number | undefined;
    maxWidth?: number | undefined;
    minHeight?: number | undefined;
    maxHeight?: number | undefined;
}>, z.ZodObject<{
    type: z.ZodLiteral<"session_metric">;
    key: z.ZodString;
    operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
    threshold: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "session_metric";
    key: string;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    threshold: number;
}, {
    type: "session_metric";
    key: string;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    threshold: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"dismissed">;
    key: z.ZodString;
    inverted: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    type: "dismissed";
    key: string;
    inverted?: boolean | undefined;
}, {
    type: "dismissed";
    key: string;
    inverted?: boolean | undefined;
}>, z.ZodObject<{
    type: z.ZodLiteral<"cooldown_active">;
    key: z.ZodString;
    inverted: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    type: "cooldown_active";
    key: string;
    inverted?: boolean | undefined;
}, {
    type: "cooldown_active";
    key: string;
    inverted?: boolean | undefined;
}>, z.ZodObject<{
    type: z.ZodLiteral<"frequency_limit">;
    key: z.ZodString;
    limit: z.ZodNumber;
    inverted: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    type: "frequency_limit";
    key: string;
    limit: number;
    inverted?: boolean | undefined;
}, {
    type: "frequency_limit";
    key: string;
    limit: number;
    inverted?: boolean | undefined;
}>, z.ZodObject<{
    type: z.ZodLiteral<"event_count">;
    key: z.ZodString;
    operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
    count: z.ZodNumber;
    withinMs: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: "event_count";
    key: string;
    count: number;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    withinMs?: number | undefined;
}, {
    type: "event_count";
    key: string;
    count: number;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    withinMs?: number | undefined;
}>]>;
export declare const RuleZ: z.ZodObject<{
    conditions: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
        type: z.ZodLiteral<"page_url">;
        url: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        url: string;
        type: "page_url";
    }, {
        url: string;
        type: "page_url";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"route">;
        routeId: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "route";
        routeId: string;
    }, {
        type: "route";
        routeId: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"anchor_visible">;
        anchorId: z.ZodString;
        state: z.ZodEnum<["visible", "present", "absent"]>;
    }, "strip", z.ZodTypeAny, {
        anchorId: string;
        state: "visible" | "present" | "absent";
        type: "anchor_visible";
    }, {
        anchorId: string;
        state: "visible" | "present" | "absent";
        type: "anchor_visible";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"event_occurred">;
        eventName: z.ZodString;
        withinMs: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        type: "event_occurred";
        eventName: string;
        withinMs?: number | undefined;
    }, {
        type: "event_occurred";
        eventName: string;
        withinMs?: number | undefined;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"state_equals">;
        key: z.ZodString;
        value: z.ZodUnknown;
    }, "strip", z.ZodTypeAny, {
        type: "state_equals";
        key: string;
        value?: unknown;
    }, {
        type: "state_equals";
        key: string;
        value?: unknown;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"viewport">;
        minWidth: z.ZodOptional<z.ZodNumber>;
        maxWidth: z.ZodOptional<z.ZodNumber>;
        minHeight: z.ZodOptional<z.ZodNumber>;
        maxHeight: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        type: "viewport";
        minWidth?: number | undefined;
        maxWidth?: number | undefined;
        minHeight?: number | undefined;
        maxHeight?: number | undefined;
    }, {
        type: "viewport";
        minWidth?: number | undefined;
        maxWidth?: number | undefined;
        minHeight?: number | undefined;
        maxHeight?: number | undefined;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"session_metric">;
        key: z.ZodString;
        operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
        threshold: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        type: "session_metric";
        key: string;
        operator: "gte" | "lte" | "eq" | "gt" | "lt";
        threshold: number;
    }, {
        type: "session_metric";
        key: string;
        operator: "gte" | "lte" | "eq" | "gt" | "lt";
        threshold: number;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"dismissed">;
        key: z.ZodString;
        inverted: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        type: "dismissed";
        key: string;
        inverted?: boolean | undefined;
    }, {
        type: "dismissed";
        key: string;
        inverted?: boolean | undefined;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"cooldown_active">;
        key: z.ZodString;
        inverted: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        type: "cooldown_active";
        key: string;
        inverted?: boolean | undefined;
    }, {
        type: "cooldown_active";
        key: string;
        inverted?: boolean | undefined;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"frequency_limit">;
        key: z.ZodString;
        limit: z.ZodNumber;
        inverted: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        type: "frequency_limit";
        key: string;
        limit: number;
        inverted?: boolean | undefined;
    }, {
        type: "frequency_limit";
        key: string;
        limit: number;
        inverted?: boolean | undefined;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"event_count">;
        key: z.ZodString;
        operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
        count: z.ZodNumber;
        withinMs: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        type: "event_count";
        key: string;
        count: number;
        operator: "gte" | "lte" | "eq" | "gt" | "lt";
        withinMs?: number | undefined;
    }, {
        type: "event_count";
        key: string;
        count: number;
        operator: "gte" | "lte" | "eq" | "gt" | "lt";
        withinMs?: number | undefined;
    }>]>, "many">;
    value: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    conditions: ({
        url: string;
        type: "page_url";
    } | {
        type: "route";
        routeId: string;
    } | {
        anchorId: string;
        state: "visible" | "present" | "absent";
        type: "anchor_visible";
    } | {
        type: "event_occurred";
        eventName: string;
        withinMs?: number | undefined;
    } | {
        type: "state_equals";
        key: string;
        value?: unknown;
    } | {
        type: "viewport";
        minWidth?: number | undefined;
        maxWidth?: number | undefined;
        minHeight?: number | undefined;
        maxHeight?: number | undefined;
    } | {
        type: "session_metric";
        key: string;
        operator: "gte" | "lte" | "eq" | "gt" | "lt";
        threshold: number;
    } | {
        type: "dismissed";
        key: string;
        inverted?: boolean | undefined;
    } | {
        type: "cooldown_active";
        key: string;
        inverted?: boolean | undefined;
    } | {
        type: "frequency_limit";
        key: string;
        limit: number;
        inverted?: boolean | undefined;
    } | {
        type: "event_count";
        key: string;
        count: number;
        operator: "gte" | "lte" | "eq" | "gt" | "lt";
        withinMs?: number | undefined;
    })[];
    value?: unknown;
}, {
    conditions: ({
        url: string;
        type: "page_url";
    } | {
        type: "route";
        routeId: string;
    } | {
        anchorId: string;
        state: "visible" | "present" | "absent";
        type: "anchor_visible";
    } | {
        type: "event_occurred";
        eventName: string;
        withinMs?: number | undefined;
    } | {
        type: "state_equals";
        key: string;
        value?: unknown;
    } | {
        type: "viewport";
        minWidth?: number | undefined;
        maxWidth?: number | undefined;
        minHeight?: number | undefined;
        maxHeight?: number | undefined;
    } | {
        type: "session_metric";
        key: string;
        operator: "gte" | "lte" | "eq" | "gt" | "lt";
        threshold: number;
    } | {
        type: "dismissed";
        key: string;
        inverted?: boolean | undefined;
    } | {
        type: "cooldown_active";
        key: string;
        inverted?: boolean | undefined;
    } | {
        type: "frequency_limit";
        key: string;
        limit: number;
        inverted?: boolean | undefined;
    } | {
        type: "event_count";
        key: string;
        count: number;
        operator: "gte" | "lte" | "eq" | "gt" | "lt";
        withinMs?: number | undefined;
    })[];
    value?: unknown;
}>;
export declare const RuleStrategyZ: z.ZodObject<{
    type: z.ZodLiteral<"rules">;
    rules: z.ZodArray<z.ZodObject<{
        conditions: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
            type: z.ZodLiteral<"page_url">;
            url: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            url: string;
            type: "page_url";
        }, {
            url: string;
            type: "page_url";
        }>, z.ZodObject<{
            type: z.ZodLiteral<"route">;
            routeId: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            type: "route";
            routeId: string;
        }, {
            type: "route";
            routeId: string;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"anchor_visible">;
            anchorId: z.ZodString;
            state: z.ZodEnum<["visible", "present", "absent"]>;
        }, "strip", z.ZodTypeAny, {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        }, {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        }>, z.ZodObject<{
            type: z.ZodLiteral<"event_occurred">;
            eventName: z.ZodString;
            withinMs: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        }, {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"state_equals">;
            key: z.ZodString;
            value: z.ZodUnknown;
        }, "strip", z.ZodTypeAny, {
            type: "state_equals";
            key: string;
            value?: unknown;
        }, {
            type: "state_equals";
            key: string;
            value?: unknown;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"viewport">;
            minWidth: z.ZodOptional<z.ZodNumber>;
            maxWidth: z.ZodOptional<z.ZodNumber>;
            minHeight: z.ZodOptional<z.ZodNumber>;
            maxHeight: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        }, {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"session_metric">;
            key: z.ZodString;
            operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
            threshold: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        }, {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"dismissed">;
            key: z.ZodString;
            inverted: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        }, {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"cooldown_active">;
            key: z.ZodString;
            inverted: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        }, {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"frequency_limit">;
            key: z.ZodString;
            limit: z.ZodNumber;
            inverted: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        }, {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"event_count">;
            key: z.ZodString;
            operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
            count: z.ZodNumber;
            withinMs: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        }, {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        }>]>, "many">;
        value: z.ZodUnknown;
    }, "strip", z.ZodTypeAny, {
        conditions: ({
            url: string;
            type: "page_url";
        } | {
            type: "route";
            routeId: string;
        } | {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        } | {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        } | {
            type: "state_equals";
            key: string;
            value?: unknown;
        } | {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        } | {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        } | {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        } | {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        })[];
        value?: unknown;
    }, {
        conditions: ({
            url: string;
            type: "page_url";
        } | {
            type: "route";
            routeId: string;
        } | {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        } | {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        } | {
            type: "state_equals";
            key: string;
            value?: unknown;
        } | {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        } | {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        } | {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        } | {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        })[];
        value?: unknown;
    }>, "many">;
    default: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    type: "rules";
    rules: {
        conditions: ({
            url: string;
            type: "page_url";
        } | {
            type: "route";
            routeId: string;
        } | {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        } | {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        } | {
            type: "state_equals";
            key: string;
            value?: unknown;
        } | {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        } | {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        } | {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        } | {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        })[];
        value?: unknown;
    }[];
    default?: unknown;
}, {
    type: "rules";
    rules: {
        conditions: ({
            url: string;
            type: "page_url";
        } | {
            type: "route";
            routeId: string;
        } | {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        } | {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        } | {
            type: "state_equals";
            key: string;
            value?: unknown;
        } | {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        } | {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        } | {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        } | {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        })[];
        value?: unknown;
    }[];
    default?: unknown;
}>;
export declare const ScoreStrategyZ: z.ZodObject<{
    type: z.ZodLiteral<"score">;
    field: z.ZodString;
    threshold: z.ZodNumber;
    above: z.ZodUnknown;
    below: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    type: "score";
    threshold: number;
    field: string;
    above?: unknown;
    below?: unknown;
}, {
    type: "score";
    threshold: number;
    field: string;
    above?: unknown;
    below?: unknown;
}>;
export declare const ModelStrategyZ: z.ZodObject<{
    type: z.ZodLiteral<"model">;
    modelId: z.ZodString;
    inputs: z.ZodArray<z.ZodString, "many">;
    outputMapping: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    default: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    type: "model";
    modelId: string;
    inputs: string[];
    outputMapping: Record<string, unknown>;
    default?: unknown;
}, {
    type: "model";
    modelId: string;
    inputs: string[];
    outputMapping: Record<string, unknown>;
    default?: unknown;
}>;
export declare const ExternalStrategyZ: z.ZodObject<{
    type: z.ZodLiteral<"external">;
    endpoint: z.ZodString;
    method: z.ZodOptional<z.ZodEnum<["GET", "POST"]>>;
    default: z.ZodUnknown;
    timeoutMs: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: "external";
    endpoint: string;
    timeoutMs?: number | undefined;
    default?: unknown;
    method?: "GET" | "POST" | undefined;
}, {
    type: "external";
    endpoint: string;
    timeoutMs?: number | undefined;
    default?: unknown;
    method?: "GET" | "POST" | undefined;
}>;
export declare const DecisionStrategyZ: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
    type: z.ZodLiteral<"rules">;
    rules: z.ZodArray<z.ZodObject<{
        conditions: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
            type: z.ZodLiteral<"page_url">;
            url: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            url: string;
            type: "page_url";
        }, {
            url: string;
            type: "page_url";
        }>, z.ZodObject<{
            type: z.ZodLiteral<"route">;
            routeId: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            type: "route";
            routeId: string;
        }, {
            type: "route";
            routeId: string;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"anchor_visible">;
            anchorId: z.ZodString;
            state: z.ZodEnum<["visible", "present", "absent"]>;
        }, "strip", z.ZodTypeAny, {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        }, {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        }>, z.ZodObject<{
            type: z.ZodLiteral<"event_occurred">;
            eventName: z.ZodString;
            withinMs: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        }, {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"state_equals">;
            key: z.ZodString;
            value: z.ZodUnknown;
        }, "strip", z.ZodTypeAny, {
            type: "state_equals";
            key: string;
            value?: unknown;
        }, {
            type: "state_equals";
            key: string;
            value?: unknown;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"viewport">;
            minWidth: z.ZodOptional<z.ZodNumber>;
            maxWidth: z.ZodOptional<z.ZodNumber>;
            minHeight: z.ZodOptional<z.ZodNumber>;
            maxHeight: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        }, {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"session_metric">;
            key: z.ZodString;
            operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
            threshold: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        }, {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"dismissed">;
            key: z.ZodString;
            inverted: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        }, {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"cooldown_active">;
            key: z.ZodString;
            inverted: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        }, {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"frequency_limit">;
            key: z.ZodString;
            limit: z.ZodNumber;
            inverted: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        }, {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"event_count">;
            key: z.ZodString;
            operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
            count: z.ZodNumber;
            withinMs: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        }, {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        }>]>, "many">;
        value: z.ZodUnknown;
    }, "strip", z.ZodTypeAny, {
        conditions: ({
            url: string;
            type: "page_url";
        } | {
            type: "route";
            routeId: string;
        } | {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        } | {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        } | {
            type: "state_equals";
            key: string;
            value?: unknown;
        } | {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        } | {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        } | {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        } | {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        })[];
        value?: unknown;
    }, {
        conditions: ({
            url: string;
            type: "page_url";
        } | {
            type: "route";
            routeId: string;
        } | {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        } | {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        } | {
            type: "state_equals";
            key: string;
            value?: unknown;
        } | {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        } | {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        } | {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        } | {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        })[];
        value?: unknown;
    }>, "many">;
    default: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    type: "rules";
    rules: {
        conditions: ({
            url: string;
            type: "page_url";
        } | {
            type: "route";
            routeId: string;
        } | {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        } | {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        } | {
            type: "state_equals";
            key: string;
            value?: unknown;
        } | {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        } | {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        } | {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        } | {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        })[];
        value?: unknown;
    }[];
    default?: unknown;
}, {
    type: "rules";
    rules: {
        conditions: ({
            url: string;
            type: "page_url";
        } | {
            type: "route";
            routeId: string;
        } | {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        } | {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        } | {
            type: "state_equals";
            key: string;
            value?: unknown;
        } | {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        } | {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        } | {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        } | {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        })[];
        value?: unknown;
    }[];
    default?: unknown;
}>, z.ZodObject<{
    type: z.ZodLiteral<"score">;
    field: z.ZodString;
    threshold: z.ZodNumber;
    above: z.ZodUnknown;
    below: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    type: "score";
    threshold: number;
    field: string;
    above?: unknown;
    below?: unknown;
}, {
    type: "score";
    threshold: number;
    field: string;
    above?: unknown;
    below?: unknown;
}>, z.ZodObject<{
    type: z.ZodLiteral<"model">;
    modelId: z.ZodString;
    inputs: z.ZodArray<z.ZodString, "many">;
    outputMapping: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    default: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    type: "model";
    modelId: string;
    inputs: string[];
    outputMapping: Record<string, unknown>;
    default?: unknown;
}, {
    type: "model";
    modelId: string;
    inputs: string[];
    outputMapping: Record<string, unknown>;
    default?: unknown;
}>, z.ZodObject<{
    type: z.ZodLiteral<"external">;
    endpoint: z.ZodString;
    method: z.ZodOptional<z.ZodEnum<["GET", "POST"]>>;
    default: z.ZodUnknown;
    timeoutMs: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: "external";
    endpoint: string;
    timeoutMs?: number | undefined;
    default?: unknown;
    method?: "GET" | "POST" | undefined;
}, {
    type: "external";
    endpoint: string;
    timeoutMs?: number | undefined;
    default?: unknown;
    method?: "GET" | "POST" | undefined;
}>]>;
export declare const RouteFilterZ: z.ZodObject<{
    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    exclude?: string[] | undefined;
    include?: string[] | undefined;
}, {
    exclude?: string[] | undefined;
    include?: string[] | undefined;
}>;
export declare const ActivationConfigZ: z.ZodObject<{
    routes: z.ZodOptional<z.ZodObject<{
        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        exclude?: string[] | undefined;
        include?: string[] | undefined;
    }, {
        exclude?: string[] | undefined;
        include?: string[] | undefined;
    }>>;
    strategy: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
        type: z.ZodLiteral<"rules">;
        rules: z.ZodArray<z.ZodObject<{
            conditions: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                type: z.ZodLiteral<"page_url">;
                url: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                url: string;
                type: "page_url";
            }, {
                url: string;
                type: "page_url";
            }>, z.ZodObject<{
                type: z.ZodLiteral<"route">;
                routeId: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "route";
                routeId: string;
            }, {
                type: "route";
                routeId: string;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"anchor_visible">;
                anchorId: z.ZodString;
                state: z.ZodEnum<["visible", "present", "absent"]>;
            }, "strip", z.ZodTypeAny, {
                anchorId: string;
                state: "visible" | "present" | "absent";
                type: "anchor_visible";
            }, {
                anchorId: string;
                state: "visible" | "present" | "absent";
                type: "anchor_visible";
            }>, z.ZodObject<{
                type: z.ZodLiteral<"event_occurred">;
                eventName: z.ZodString;
                withinMs: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                type: "event_occurred";
                eventName: string;
                withinMs?: number | undefined;
            }, {
                type: "event_occurred";
                eventName: string;
                withinMs?: number | undefined;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"state_equals">;
                key: z.ZodString;
                value: z.ZodUnknown;
            }, "strip", z.ZodTypeAny, {
                type: "state_equals";
                key: string;
                value?: unknown;
            }, {
                type: "state_equals";
                key: string;
                value?: unknown;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"viewport">;
                minWidth: z.ZodOptional<z.ZodNumber>;
                maxWidth: z.ZodOptional<z.ZodNumber>;
                minHeight: z.ZodOptional<z.ZodNumber>;
                maxHeight: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                type: "viewport";
                minWidth?: number | undefined;
                maxWidth?: number | undefined;
                minHeight?: number | undefined;
                maxHeight?: number | undefined;
            }, {
                type: "viewport";
                minWidth?: number | undefined;
                maxWidth?: number | undefined;
                minHeight?: number | undefined;
                maxHeight?: number | undefined;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"session_metric">;
                key: z.ZodString;
                operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
                threshold: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                type: "session_metric";
                key: string;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                threshold: number;
            }, {
                type: "session_metric";
                key: string;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                threshold: number;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"dismissed">;
                key: z.ZodString;
                inverted: z.ZodOptional<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                type: "dismissed";
                key: string;
                inverted?: boolean | undefined;
            }, {
                type: "dismissed";
                key: string;
                inverted?: boolean | undefined;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"cooldown_active">;
                key: z.ZodString;
                inverted: z.ZodOptional<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                type: "cooldown_active";
                key: string;
                inverted?: boolean | undefined;
            }, {
                type: "cooldown_active";
                key: string;
                inverted?: boolean | undefined;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"frequency_limit">;
                key: z.ZodString;
                limit: z.ZodNumber;
                inverted: z.ZodOptional<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                type: "frequency_limit";
                key: string;
                limit: number;
                inverted?: boolean | undefined;
            }, {
                type: "frequency_limit";
                key: string;
                limit: number;
                inverted?: boolean | undefined;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"event_count">;
                key: z.ZodString;
                operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
                count: z.ZodNumber;
                withinMs: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                type: "event_count";
                key: string;
                count: number;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                withinMs?: number | undefined;
            }, {
                type: "event_count";
                key: string;
                count: number;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                withinMs?: number | undefined;
            }>]>, "many">;
            value: z.ZodUnknown;
        }, "strip", z.ZodTypeAny, {
            conditions: ({
                url: string;
                type: "page_url";
            } | {
                type: "route";
                routeId: string;
            } | {
                anchorId: string;
                state: "visible" | "present" | "absent";
                type: "anchor_visible";
            } | {
                type: "event_occurred";
                eventName: string;
                withinMs?: number | undefined;
            } | {
                type: "state_equals";
                key: string;
                value?: unknown;
            } | {
                type: "viewport";
                minWidth?: number | undefined;
                maxWidth?: number | undefined;
                minHeight?: number | undefined;
                maxHeight?: number | undefined;
            } | {
                type: "session_metric";
                key: string;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                threshold: number;
            } | {
                type: "dismissed";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "cooldown_active";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "frequency_limit";
                key: string;
                limit: number;
                inverted?: boolean | undefined;
            } | {
                type: "event_count";
                key: string;
                count: number;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                withinMs?: number | undefined;
            })[];
            value?: unknown;
        }, {
            conditions: ({
                url: string;
                type: "page_url";
            } | {
                type: "route";
                routeId: string;
            } | {
                anchorId: string;
                state: "visible" | "present" | "absent";
                type: "anchor_visible";
            } | {
                type: "event_occurred";
                eventName: string;
                withinMs?: number | undefined;
            } | {
                type: "state_equals";
                key: string;
                value?: unknown;
            } | {
                type: "viewport";
                minWidth?: number | undefined;
                maxWidth?: number | undefined;
                minHeight?: number | undefined;
                maxHeight?: number | undefined;
            } | {
                type: "session_metric";
                key: string;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                threshold: number;
            } | {
                type: "dismissed";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "cooldown_active";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "frequency_limit";
                key: string;
                limit: number;
                inverted?: boolean | undefined;
            } | {
                type: "event_count";
                key: string;
                count: number;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                withinMs?: number | undefined;
            })[];
            value?: unknown;
        }>, "many">;
        default: z.ZodUnknown;
    }, "strip", z.ZodTypeAny, {
        type: "rules";
        rules: {
            conditions: ({
                url: string;
                type: "page_url";
            } | {
                type: "route";
                routeId: string;
            } | {
                anchorId: string;
                state: "visible" | "present" | "absent";
                type: "anchor_visible";
            } | {
                type: "event_occurred";
                eventName: string;
                withinMs?: number | undefined;
            } | {
                type: "state_equals";
                key: string;
                value?: unknown;
            } | {
                type: "viewport";
                minWidth?: number | undefined;
                maxWidth?: number | undefined;
                minHeight?: number | undefined;
                maxHeight?: number | undefined;
            } | {
                type: "session_metric";
                key: string;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                threshold: number;
            } | {
                type: "dismissed";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "cooldown_active";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "frequency_limit";
                key: string;
                limit: number;
                inverted?: boolean | undefined;
            } | {
                type: "event_count";
                key: string;
                count: number;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                withinMs?: number | undefined;
            })[];
            value?: unknown;
        }[];
        default?: unknown;
    }, {
        type: "rules";
        rules: {
            conditions: ({
                url: string;
                type: "page_url";
            } | {
                type: "route";
                routeId: string;
            } | {
                anchorId: string;
                state: "visible" | "present" | "absent";
                type: "anchor_visible";
            } | {
                type: "event_occurred";
                eventName: string;
                withinMs?: number | undefined;
            } | {
                type: "state_equals";
                key: string;
                value?: unknown;
            } | {
                type: "viewport";
                minWidth?: number | undefined;
                maxWidth?: number | undefined;
                minHeight?: number | undefined;
                maxHeight?: number | undefined;
            } | {
                type: "session_metric";
                key: string;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                threshold: number;
            } | {
                type: "dismissed";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "cooldown_active";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "frequency_limit";
                key: string;
                limit: number;
                inverted?: boolean | undefined;
            } | {
                type: "event_count";
                key: string;
                count: number;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                withinMs?: number | undefined;
            })[];
            value?: unknown;
        }[];
        default?: unknown;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"score">;
        field: z.ZodString;
        threshold: z.ZodNumber;
        above: z.ZodUnknown;
        below: z.ZodUnknown;
    }, "strip", z.ZodTypeAny, {
        type: "score";
        threshold: number;
        field: string;
        above?: unknown;
        below?: unknown;
    }, {
        type: "score";
        threshold: number;
        field: string;
        above?: unknown;
        below?: unknown;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"model">;
        modelId: z.ZodString;
        inputs: z.ZodArray<z.ZodString, "many">;
        outputMapping: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        default: z.ZodUnknown;
    }, "strip", z.ZodTypeAny, {
        type: "model";
        modelId: string;
        inputs: string[];
        outputMapping: Record<string, unknown>;
        default?: unknown;
    }, {
        type: "model";
        modelId: string;
        inputs: string[];
        outputMapping: Record<string, unknown>;
        default?: unknown;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"external">;
        endpoint: z.ZodString;
        method: z.ZodOptional<z.ZodEnum<["GET", "POST"]>>;
        default: z.ZodUnknown;
        timeoutMs: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        type: "external";
        endpoint: string;
        timeoutMs?: number | undefined;
        default?: unknown;
        method?: "GET" | "POST" | undefined;
    }, {
        type: "external";
        endpoint: string;
        timeoutMs?: number | undefined;
        default?: unknown;
        method?: "GET" | "POST" | undefined;
    }>]>>;
}, "strip", z.ZodTypeAny, {
    strategy?: {
        type: "rules";
        rules: {
            conditions: ({
                url: string;
                type: "page_url";
            } | {
                type: "route";
                routeId: string;
            } | {
                anchorId: string;
                state: "visible" | "present" | "absent";
                type: "anchor_visible";
            } | {
                type: "event_occurred";
                eventName: string;
                withinMs?: number | undefined;
            } | {
                type: "state_equals";
                key: string;
                value?: unknown;
            } | {
                type: "viewport";
                minWidth?: number | undefined;
                maxWidth?: number | undefined;
                minHeight?: number | undefined;
                maxHeight?: number | undefined;
            } | {
                type: "session_metric";
                key: string;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                threshold: number;
            } | {
                type: "dismissed";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "cooldown_active";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "frequency_limit";
                key: string;
                limit: number;
                inverted?: boolean | undefined;
            } | {
                type: "event_count";
                key: string;
                count: number;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                withinMs?: number | undefined;
            })[];
            value?: unknown;
        }[];
        default?: unknown;
    } | {
        type: "score";
        threshold: number;
        field: string;
        above?: unknown;
        below?: unknown;
    } | {
        type: "model";
        modelId: string;
        inputs: string[];
        outputMapping: Record<string, unknown>;
        default?: unknown;
    } | {
        type: "external";
        endpoint: string;
        timeoutMs?: number | undefined;
        default?: unknown;
        method?: "GET" | "POST" | undefined;
    } | undefined;
    routes?: {
        exclude?: string[] | undefined;
        include?: string[] | undefined;
    } | undefined;
}, {
    strategy?: {
        type: "rules";
        rules: {
            conditions: ({
                url: string;
                type: "page_url";
            } | {
                type: "route";
                routeId: string;
            } | {
                anchorId: string;
                state: "visible" | "present" | "absent";
                type: "anchor_visible";
            } | {
                type: "event_occurred";
                eventName: string;
                withinMs?: number | undefined;
            } | {
                type: "state_equals";
                key: string;
                value?: unknown;
            } | {
                type: "viewport";
                minWidth?: number | undefined;
                maxWidth?: number | undefined;
                minHeight?: number | undefined;
                maxHeight?: number | undefined;
            } | {
                type: "session_metric";
                key: string;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                threshold: number;
            } | {
                type: "dismissed";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "cooldown_active";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "frequency_limit";
                key: string;
                limit: number;
                inverted?: boolean | undefined;
            } | {
                type: "event_count";
                key: string;
                count: number;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                withinMs?: number | undefined;
            })[];
            value?: unknown;
        }[];
        default?: unknown;
    } | {
        type: "score";
        threshold: number;
        field: string;
        above?: unknown;
        below?: unknown;
    } | {
        type: "model";
        modelId: string;
        inputs: string[];
        outputMapping: Record<string, unknown>;
        default?: unknown;
    } | {
        type: "external";
        endpoint: string;
        timeoutMs?: number | undefined;
        default?: unknown;
        method?: "GET" | "POST" | undefined;
    } | undefined;
    routes?: {
        exclude?: string[] | undefined;
        include?: string[] | undefined;
    } | undefined;
}>;
/**
 * Validate a Condition object.
 */
export declare function validateCondition(data: unknown): z.SafeParseReturnType<{
    url: string;
    type: "page_url";
} | {
    type: "route";
    routeId: string;
} | {
    anchorId: string;
    state: "visible" | "present" | "absent";
    type: "anchor_visible";
} | {
    type: "event_occurred";
    eventName: string;
    withinMs?: number | undefined;
} | {
    type: "state_equals";
    key: string;
    value?: unknown;
} | {
    type: "viewport";
    minWidth?: number | undefined;
    maxWidth?: number | undefined;
    minHeight?: number | undefined;
    maxHeight?: number | undefined;
} | {
    type: "session_metric";
    key: string;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    threshold: number;
} | {
    type: "dismissed";
    key: string;
    inverted?: boolean | undefined;
} | {
    type: "cooldown_active";
    key: string;
    inverted?: boolean | undefined;
} | {
    type: "frequency_limit";
    key: string;
    limit: number;
    inverted?: boolean | undefined;
} | {
    type: "event_count";
    key: string;
    count: number;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    withinMs?: number | undefined;
}, {
    url: string;
    type: "page_url";
} | {
    type: "route";
    routeId: string;
} | {
    anchorId: string;
    state: "visible" | "present" | "absent";
    type: "anchor_visible";
} | {
    type: "event_occurred";
    eventName: string;
    withinMs?: number | undefined;
} | {
    type: "state_equals";
    key: string;
    value?: unknown;
} | {
    type: "viewport";
    minWidth?: number | undefined;
    maxWidth?: number | undefined;
    minHeight?: number | undefined;
    maxHeight?: number | undefined;
} | {
    type: "session_metric";
    key: string;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    threshold: number;
} | {
    type: "dismissed";
    key: string;
    inverted?: boolean | undefined;
} | {
    type: "cooldown_active";
    key: string;
    inverted?: boolean | undefined;
} | {
    type: "frequency_limit";
    key: string;
    limit: number;
    inverted?: boolean | undefined;
} | {
    type: "event_count";
    key: string;
    count: number;
    operator: "gte" | "lte" | "eq" | "gt" | "lt";
    withinMs?: number | undefined;
}>;
/**
 * Validate a DecisionStrategy object.
 */
export declare function validateStrategy(data: unknown): z.SafeParseReturnType<{
    type: "rules";
    rules: {
        conditions: ({
            url: string;
            type: "page_url";
        } | {
            type: "route";
            routeId: string;
        } | {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        } | {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        } | {
            type: "state_equals";
            key: string;
            value?: unknown;
        } | {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        } | {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        } | {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        } | {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        })[];
        value?: unknown;
    }[];
    default?: unknown;
} | {
    type: "score";
    threshold: number;
    field: string;
    above?: unknown;
    below?: unknown;
} | {
    type: "model";
    modelId: string;
    inputs: string[];
    outputMapping: Record<string, unknown>;
    default?: unknown;
} | {
    type: "external";
    endpoint: string;
    timeoutMs?: number | undefined;
    default?: unknown;
    method?: "GET" | "POST" | undefined;
}, {
    type: "rules";
    rules: {
        conditions: ({
            url: string;
            type: "page_url";
        } | {
            type: "route";
            routeId: string;
        } | {
            anchorId: string;
            state: "visible" | "present" | "absent";
            type: "anchor_visible";
        } | {
            type: "event_occurred";
            eventName: string;
            withinMs?: number | undefined;
        } | {
            type: "state_equals";
            key: string;
            value?: unknown;
        } | {
            type: "viewport";
            minWidth?: number | undefined;
            maxWidth?: number | undefined;
            minHeight?: number | undefined;
            maxHeight?: number | undefined;
        } | {
            type: "session_metric";
            key: string;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            threshold: number;
        } | {
            type: "dismissed";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "cooldown_active";
            key: string;
            inverted?: boolean | undefined;
        } | {
            type: "frequency_limit";
            key: string;
            limit: number;
            inverted?: boolean | undefined;
        } | {
            type: "event_count";
            key: string;
            count: number;
            operator: "gte" | "lte" | "eq" | "gt" | "lt";
            withinMs?: number | undefined;
        })[];
        value?: unknown;
    }[];
    default?: unknown;
} | {
    type: "score";
    threshold: number;
    field: string;
    above?: unknown;
    below?: unknown;
} | {
    type: "model";
    modelId: string;
    inputs: string[];
    outputMapping: Record<string, unknown>;
    default?: unknown;
} | {
    type: "external";
    endpoint: string;
    timeoutMs?: number | undefined;
    default?: unknown;
    method?: "GET" | "POST" | undefined;
}>;
/**
 * Validate an ActivationConfig object.
 */
export declare function validateActivationConfig(data: unknown): z.SafeParseReturnType<{
    strategy?: {
        type: "rules";
        rules: {
            conditions: ({
                url: string;
                type: "page_url";
            } | {
                type: "route";
                routeId: string;
            } | {
                anchorId: string;
                state: "visible" | "present" | "absent";
                type: "anchor_visible";
            } | {
                type: "event_occurred";
                eventName: string;
                withinMs?: number | undefined;
            } | {
                type: "state_equals";
                key: string;
                value?: unknown;
            } | {
                type: "viewport";
                minWidth?: number | undefined;
                maxWidth?: number | undefined;
                minHeight?: number | undefined;
                maxHeight?: number | undefined;
            } | {
                type: "session_metric";
                key: string;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                threshold: number;
            } | {
                type: "dismissed";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "cooldown_active";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "frequency_limit";
                key: string;
                limit: number;
                inverted?: boolean | undefined;
            } | {
                type: "event_count";
                key: string;
                count: number;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                withinMs?: number | undefined;
            })[];
            value?: unknown;
        }[];
        default?: unknown;
    } | {
        type: "score";
        threshold: number;
        field: string;
        above?: unknown;
        below?: unknown;
    } | {
        type: "model";
        modelId: string;
        inputs: string[];
        outputMapping: Record<string, unknown>;
        default?: unknown;
    } | {
        type: "external";
        endpoint: string;
        timeoutMs?: number | undefined;
        default?: unknown;
        method?: "GET" | "POST" | undefined;
    } | undefined;
    routes?: {
        exclude?: string[] | undefined;
        include?: string[] | undefined;
    } | undefined;
}, {
    strategy?: {
        type: "rules";
        rules: {
            conditions: ({
                url: string;
                type: "page_url";
            } | {
                type: "route";
                routeId: string;
            } | {
                anchorId: string;
                state: "visible" | "present" | "absent";
                type: "anchor_visible";
            } | {
                type: "event_occurred";
                eventName: string;
                withinMs?: number | undefined;
            } | {
                type: "state_equals";
                key: string;
                value?: unknown;
            } | {
                type: "viewport";
                minWidth?: number | undefined;
                maxWidth?: number | undefined;
                minHeight?: number | undefined;
                maxHeight?: number | undefined;
            } | {
                type: "session_metric";
                key: string;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                threshold: number;
            } | {
                type: "dismissed";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "cooldown_active";
                key: string;
                inverted?: boolean | undefined;
            } | {
                type: "frequency_limit";
                key: string;
                limit: number;
                inverted?: boolean | undefined;
            } | {
                type: "event_count";
                key: string;
                count: number;
                operator: "gte" | "lte" | "eq" | "gt" | "lt";
                withinMs?: number | undefined;
            })[];
            value?: unknown;
        }[];
        default?: unknown;
    } | {
        type: "score";
        threshold: number;
        field: string;
        above?: unknown;
        below?: unknown;
    } | {
        type: "model";
        modelId: string;
        inputs: string[];
        outputMapping: Record<string, unknown>;
        default?: unknown;
    } | {
        type: "external";
        endpoint: string;
        timeoutMs?: number | undefined;
        default?: unknown;
        method?: "GET" | "POST" | undefined;
    } | undefined;
    routes?: {
        exclude?: string[] | undefined;
        include?: string[] | undefined;
    } | undefined;
}>;
export type ConditionSchema = z.infer<typeof ConditionZ>;
export type RuleSchema = z.infer<typeof RuleZ>;
export type DecisionStrategySchema = z.infer<typeof DecisionStrategyZ>;
export type ActivationConfigSchema = z.infer<typeof ActivationConfigZ>;
