import { z } from 'zod/v4';
export type Audience = z.infer<typeof audienceSchema>;
export type CreateAudienceBody = z.input<typeof createAudienceSchema>;
export type CreateAudienceArgs = z.output<typeof createAudienceSchema>;
export type UpdateAudienceBody = z.input<typeof updateAudienceSchema>;
export type UpdateAudienceArgs = z.output<typeof updateAudienceSchema>;
export type SearchAudiencesQuery = z.input<typeof searchAudiencesSchema>;
export type SearchAudiencesArgs = z.output<typeof searchAudiencesSchema>;
export type AudienceItemParamsSchema = z.infer<typeof audienceItemParamsSchema>;
export type AudienceCollectionParamsSchema = z.infer<typeof audienceCollectionParamsSchema>;
export declare const audienceSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodString;
    ruleSets: z.ZodArray<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>>;
    workspaceId: z.ZodString;
    createdAt: z.ZodNumber;
    updatedAt: z.ZodNumber;
    createdBy: z.ZodUnion<[z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        email: z.ZodEmail;
        profileImageUrl: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodNull]>;
    updatedBy: z.ZodUnion<[z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        email: z.ZodEmail;
        profileImageUrl: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodNull]>;
}, z.core.$strip>;
export declare const audienceCollectionSchema: z.ZodObject<{
    data: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        description: z.ZodString;
        ruleSets: z.ZodArray<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>>;
        workspaceId: z.ZodString;
        createdAt: z.ZodNumber;
        updatedAt: z.ZodNumber;
        createdBy: z.ZodUnion<[z.ZodObject<{
            id: z.ZodString;
            name: z.ZodString;
            email: z.ZodEmail;
            profileImageUrl: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>, z.ZodNull]>;
        updatedBy: z.ZodUnion<[z.ZodObject<{
            id: z.ZodString;
            name: z.ZodString;
            email: z.ZodEmail;
            profileImageUrl: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>, z.ZodNull]>;
    }, z.core.$strip>>;
    totalCount: z.ZodNumber;
}, z.core.$strip>;
export declare const createAudienceSchema: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    ruleSets: z.ZodArray<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>>;
}, z.core.$strip>;
export declare const updateAudienceSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    ruleSets: z.ZodOptional<z.ZodArray<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>>>;
}, z.core.$strip>;
export declare const searchAudiencesSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    limit: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodTransform<number, string>>;
    offset: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodTransform<number, string>>;
}, z.core.$strip>;
export declare const audienceCollectionParamsSchema: z.ZodObject<{
    workspaceId: z.ZodString;
}, z.core.$strip>;
export declare const audienceItemParamsSchema: z.ZodObject<{
    workspaceId: z.ZodString;
    audienceId: z.ZodString;
}, z.core.$strip>;