import * as z from 'zod/v4';
declare const FuzzyMatcher: z.ZodObject<{
    fieldId: z.ZodString;
    type: z.ZodLiteral<"fuzzy">;
    options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
        fuzziness: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
        boost: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        matchAgainst: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
export type FuzzyMatcherOptions = z.input<typeof FuzzyMatcher>['options'];
declare const StrictMatcher: z.ZodObject<{
    fieldId: z.ZodString;
    type: z.ZodLiteral<"strict">;
    options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
        boost: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        value: z.ZodOptional<z.ZodString>;
        matchAgainst: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
export type StrictMatcherOptions = z.input<typeof StrictMatcher>['options'];
declare const DateRangeMatcher: z.ZodObject<{
    fieldId: z.ZodString;
    type: z.ZodLiteral<"dateRange">;
    options: z.ZodObject<{
        pivot: z.ZodOptional<z.ZodNumber>;
        days: z.ZodNumber;
        boost: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        matchAgainst: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
}, z.core.$strip>;
export type DateRangeMatcherOptions = z.input<typeof DateRangeMatcher>['options'];
export type NotInput = {
    type: 'not';
    clause: ClauseInput;
};
export type NotOutput = {
    type: 'not';
    clause: ClauseOutput;
};
export type AndInput = {
    type: 'and';
    clauses: ClauseInput[];
};
export type AndOutput = {
    type: 'and';
    clauses: ClauseOutput[];
};
export type OrInput = {
    type: 'or';
    clauses: ClauseInput[];
};
export type OrOutput = {
    type: 'or';
    clauses: ClauseOutput[];
};
export type ClauseInput = NotInput | AndInput | OrInput | z.input<typeof FuzzyMatcher> | z.input<typeof StrictMatcher> | z.input<typeof DateRangeMatcher>;
export type ClauseOutput = NotOutput | AndOutput | OrOutput | z.output<typeof FuzzyMatcher> | z.output<typeof StrictMatcher> | z.output<typeof DateRangeMatcher>;
/**
 * Defines a deduplication clause. Clauses are either matcher clauses or logical clauses. Logical clauses (and, or) are used to combine multiple clauses.
 * Since the definiton is recursive, we use z.lazy to define the schema.
 * Zod supports recursive schemas, but needs help with Input and Output types.
 *
 * Default assumption is that the ZodType is the input. Markers use default values, so we need to explicitly define output type, too.
 *
 */
export declare const Clause: z.ZodType<ClauseOutput, ClauseInput>;
export type Clause = z.infer<typeof Clause>;
export declare const DeduplicationConfig: z.ZodObject<{
    id: z.ZodString;
    label: z.ZodObject<import("./TranslationConfig").MessageDescriptorZod, z.core.$strip>;
    query: z.ZodType<ClauseOutput, ClauseInput, z.core.$ZodTypeInternals<ClauseOutput, ClauseInput>>;
}, z.core.$strip>;
export type DeduplicationConfigInput = z.input<typeof DeduplicationConfig>;
export type DeduplicationConfig = z.infer<typeof DeduplicationConfig>;
export {};
//# sourceMappingURL=DeduplicationConfig.d.ts.map