import { z } from 'zod/v4';
export type ConditionRule = z.infer<typeof conditionRuleSchema>;
export type AudienceRule = z.infer<typeof audienceRuleSchema>;
export type AudienceRuleSet = z.infer<typeof audienceRuleSetSchema>;
export declare const conditionRuleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Event>;
    eventType: z.ZodEnum<typeof import("./UserEvent").UserEventType>;
    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
    selector: z.ZodOptional<z.ZodString>;
    key: z.ZodOptional<z.ZodString>;
    url: z.ZodOptional<z.ZodString>;
    value: z.ZodNumber;
    operator: z.ZodEnum<{
        readonly Equals: import("./Operator").NumericOperator.Equals;
        readonly NotEquals: import("./Operator").NumericOperator.NotEquals;
        readonly GreaterThan: import("./Operator").NumericOperator.GreaterThan;
        readonly LessThan: import("./Operator").NumericOperator.LessThan;
        readonly GreaterThanOrEquals: import("./Operator").NumericOperator.GreaterThanOrEquals;
        readonly LessThanOrEquals: import("./Operator").NumericOperator.LessThanOrEquals;
    }>;
    from: z.ZodEnum<typeof import("./TimeRange").TimeRange>;
    direction: z.ZodOptional<z.ZodEnum<typeof import("./Direction").Direction>>;
    threshold: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.CustomAttribute>;
    key: z.ZodString;
    value: z.ZodString;
    operator: z.ZodEnum<typeof import("./Operator").StringOperator>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Country>;
    value: z.ZodString;
    operator: z.ZodEnum<{
        readonly Is: import("./Operator").BooleanOperator.Is;
        readonly IsNot: import("./Operator").BooleanOperator.IsNot;
    }>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Language>;
    value: z.ZodString;
    operator: z.ZodEnum<{
        readonly Is: import("./Operator").BooleanOperator.Is;
        readonly IsNot: import("./Operator").BooleanOperator.IsNot;
    }>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Referrer>;
    value: z.ZodString;
    operator: z.ZodEnum<{
        readonly Is: import("./Operator").StringOperator.Is;
        readonly IsNot: import("./Operator").StringOperator.IsNot;
        readonly Contains: import("./Operator").StringOperator.Contains;
        readonly DoesNotContains: import("./Operator").StringOperator.DoesNotContains;
        readonly StartsWith: import("./Operator").StringOperator.StartsWith;
        readonly EndsWith: import("./Operator").StringOperator.EndsWith;
    }>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<"url">;
    value: z.ZodString;
    operator: z.ZodEnum<{
        readonly Is: import("./Operator").StringOperator.Is;
        readonly IsNot: import("./Operator").StringOperator.IsNot;
        readonly Contains: import("./Operator").StringOperator.Contains;
        readonly DoesNotContains: import("./Operator").StringOperator.DoesNotContains;
        readonly StartsWith: import("./Operator").StringOperator.StartsWith;
        readonly EndsWith: import("./Operator").StringOperator.EndsWith;
    }>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Device>;
    value: z.ZodString;
    operator: z.ZodEnum<{
        readonly Is: import("./Operator").BooleanOperator.Is;
        readonly IsNot: import("./Operator").BooleanOperator.IsNot;
    }>;
}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
    valueType: z.ZodLiteral<import("./Operator").ValueType.String>;
    value: z.ZodString;
    operator: z.ZodEnum<typeof import("./Operator").StringOperator>;
    type: z.ZodLiteral<"webhookRequest">;
    key: z.ZodString;
    from: z.ZodEnum<typeof import("./TimeRange").TimeRange>;
    webhookId: z.ZodString;
}, z.core.$strip>, z.ZodObject<{
    valueType: z.ZodLiteral<import("./Operator").ValueType.Number>;
    value: z.ZodNumber;
    operator: z.ZodEnum<typeof import("./Operator").NumericOperator>;
    type: z.ZodLiteral<"webhookRequest">;
    key: z.ZodString;
    from: z.ZodEnum<typeof import("./TimeRange").TimeRange>;
    webhookId: z.ZodString;
}, z.core.$strip>, z.ZodObject<{
    valueType: z.ZodLiteral<import("./Operator").ValueType.Boolean>;
    value: z.ZodBoolean;
    operator: z.ZodEnum<typeof import("./Operator").BooleanOperator>;
    type: z.ZodLiteral<"webhookRequest">;
    key: z.ZodString;
    from: z.ZodEnum<typeof import("./TimeRange").TimeRange>;
    webhookId: z.ZodString;
}, z.core.$strip>]>]>;
declare const audienceRuleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Event>;
    eventType: z.ZodEnum<typeof import("./UserEvent").UserEventType>;
    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
    selector: z.ZodOptional<z.ZodString>;
    key: z.ZodOptional<z.ZodString>;
    url: z.ZodOptional<z.ZodString>;
    value: z.ZodNumber;
    operator: z.ZodEnum<{
        readonly Equals: import("./Operator").NumericOperator.Equals;
        readonly NotEquals: import("./Operator").NumericOperator.NotEquals;
        readonly GreaterThan: import("./Operator").NumericOperator.GreaterThan;
        readonly LessThan: import("./Operator").NumericOperator.LessThan;
        readonly GreaterThanOrEquals: import("./Operator").NumericOperator.GreaterThanOrEquals;
        readonly LessThanOrEquals: import("./Operator").NumericOperator.LessThanOrEquals;
    }>;
    from: z.ZodEnum<typeof import("./TimeRange").TimeRange>;
    direction: z.ZodOptional<z.ZodEnum<typeof import("./Direction").Direction>>;
    threshold: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.CustomAttribute>;
    key: z.ZodString;
    value: z.ZodString;
    operator: z.ZodEnum<typeof import("./Operator").StringOperator>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Country>;
    value: z.ZodString;
    operator: z.ZodEnum<{
        readonly Is: import("./Operator").BooleanOperator.Is;
        readonly IsNot: import("./Operator").BooleanOperator.IsNot;
    }>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Language>;
    value: z.ZodString;
    operator: z.ZodEnum<{
        readonly Is: import("./Operator").BooleanOperator.Is;
        readonly IsNot: import("./Operator").BooleanOperator.IsNot;
    }>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Referrer>;
    value: z.ZodString;
    operator: z.ZodEnum<{
        readonly Is: import("./Operator").StringOperator.Is;
        readonly IsNot: import("./Operator").StringOperator.IsNot;
        readonly Contains: import("./Operator").StringOperator.Contains;
        readonly DoesNotContains: import("./Operator").StringOperator.DoesNotContains;
        readonly StartsWith: import("./Operator").StringOperator.StartsWith;
        readonly EndsWith: import("./Operator").StringOperator.EndsWith;
    }>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Device>;
    value: z.ZodString;
    operator: z.ZodEnum<{
        readonly Is: import("./Operator").BooleanOperator.Is;
        readonly IsNot: import("./Operator").BooleanOperator.IsNot;
    }>;
}, z.core.$strip>]>;
export declare const audienceRuleSetSchema: z.ZodObject<{
    label: z.ZodString;
    or: z.ZodArray<z.ZodObject<{
        and: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Event>;
            eventType: z.ZodEnum<typeof import("./UserEvent").UserEventType>;
            tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
            selector: z.ZodOptional<z.ZodString>;
            key: z.ZodOptional<z.ZodString>;
            url: z.ZodOptional<z.ZodString>;
            value: z.ZodNumber;
            operator: z.ZodEnum<{
                readonly Equals: import("./Operator").NumericOperator.Equals;
                readonly NotEquals: import("./Operator").NumericOperator.NotEquals;
                readonly GreaterThan: import("./Operator").NumericOperator.GreaterThan;
                readonly LessThan: import("./Operator").NumericOperator.LessThan;
                readonly GreaterThanOrEquals: import("./Operator").NumericOperator.GreaterThanOrEquals;
                readonly LessThanOrEquals: import("./Operator").NumericOperator.LessThanOrEquals;
            }>;
            from: z.ZodEnum<typeof import("./TimeRange").TimeRange>;
            direction: z.ZodOptional<z.ZodEnum<typeof import("./Direction").Direction>>;
            threshold: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<import("./RuleType").AudienceRuleType.CustomAttribute>;
            key: z.ZodString;
            value: z.ZodString;
            operator: z.ZodEnum<typeof import("./Operator").StringOperator>;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Country>;
            value: z.ZodString;
            operator: z.ZodEnum<{
                readonly Is: import("./Operator").BooleanOperator.Is;
                readonly IsNot: import("./Operator").BooleanOperator.IsNot;
            }>;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Language>;
            value: z.ZodString;
            operator: z.ZodEnum<{
                readonly Is: import("./Operator").BooleanOperator.Is;
                readonly IsNot: import("./Operator").BooleanOperator.IsNot;
            }>;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Referrer>;
            value: z.ZodString;
            operator: z.ZodEnum<{
                readonly Is: import("./Operator").StringOperator.Is;
                readonly IsNot: import("./Operator").StringOperator.IsNot;
                readonly Contains: import("./Operator").StringOperator.Contains;
                readonly DoesNotContains: import("./Operator").StringOperator.DoesNotContains;
                readonly StartsWith: import("./Operator").StringOperator.StartsWith;
                readonly EndsWith: import("./Operator").StringOperator.EndsWith;
            }>;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<import("./RuleType").AudienceRuleType.Device>;
            value: z.ZodString;
            operator: z.ZodEnum<{
                readonly Is: import("./Operator").BooleanOperator.Is;
                readonly IsNot: import("./Operator").BooleanOperator.IsNot;
            }>;
        }, z.core.$strip>]>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
export {};