/// <reference types="node" resolution-mode="require"/>
import { JSDOM } from 'jsdom';
import { z } from 'zod';
export declare const match: z.ZodObject<{
    idx: z.ZodNumber;
    regex: z.ZodType<RegExp, z.ZodTypeDef, RegExp>;
    matched: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    regex: RegExp;
    idx: number;
    matched: boolean;
}, {
    regex: RegExp;
    idx: number;
    matched: boolean;
}>;
export declare const config_schema: z.ZodObject<{
    dom: z.ZodType<JSDOM, z.ZodTypeDef, JSDOM>;
    matches: z.ZodArray<z.ZodObject<{
        idx: z.ZodNumber;
        regex: z.ZodType<RegExp, z.ZodTypeDef, RegExp>;
        matched: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        regex: RegExp;
        idx: number;
        matched: boolean;
    }, {
        regex: RegExp;
        idx: number;
        matched: boolean;
    }>, "many">;
    rules: z.ZodArray<z.ZodObject<{
        audioInnerHTML: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodString, "many">], z.ZodUnknown>, z.ZodString>>;
        cssSelectors: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
        hosting: z.ZodObject<{
            config: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
            write: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodPromise<z.ZodUnion<[z.ZodObject<{
                error: z.ZodType<Error, z.ZodTypeDef, Error>;
                value: z.ZodOptional<z.ZodUndefined>;
            }, "strip", z.ZodTypeAny, {
                error: Error;
                value?: undefined;
            }, {
                error: Error;
                value?: undefined;
            }>, z.ZodObject<{
                error: z.ZodOptional<z.ZodUndefined>;
                value: z.ZodObject<{
                    href: z.ZodString;
                    message: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    message: string;
                    href: string;
                }, {
                    message: string;
                    href: string;
                }>;
            }, "strip", z.ZodTypeAny, {
                value: {
                    message: string;
                    href: string;
                };
                error?: undefined;
            }, {
                value: {
                    message: string;
                    href: string;
                };
                error?: undefined;
            }>]>>>;
        }, "strip", z.ZodTypeAny, {
            config: {} & {
                [k: string]: unknown;
            };
            write: (...args: unknown[]) => Promise<{
                value: {
                    message: string;
                    href: string;
                };
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        }, {
            config: {} & {
                [k: string]: unknown;
            };
            write: (...args: unknown[]) => Promise<{
                value: {
                    message: string;
                    href: string;
                };
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        }>;
        regex: z.ZodDefault<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
        synthesis: z.ZodObject<{
            config: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
            extension: z.ZodString;
            synthesize: z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodUnion<[z.ZodObject<{
                error: z.ZodType<Error, z.ZodTypeDef, Error>;
                value: z.ZodOptional<z.ZodUndefined>;
            }, "strip", z.ZodTypeAny, {
                error: Error;
                value?: undefined;
            }, {
                error: Error;
                value?: undefined;
            }>, z.ZodObject<{
                error: z.ZodOptional<z.ZodUndefined>;
                value: z.ZodType<import("stream").Readable, z.ZodTypeDef, import("stream").Readable>;
            }, "strip", z.ZodTypeAny, {
                value: import("stream").Readable;
                error?: undefined;
            }, {
                value: import("stream").Readable;
                error?: undefined;
            }>]>>>;
        }, "strip", z.ZodTypeAny, {
            config: {} & {
                [k: string]: unknown;
            };
            extension: string;
            synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
                value: import("stream").Readable;
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        }, {
            config: {} & {
                [k: string]: unknown;
            };
            extension: string;
            synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
                value: import("stream").Readable;
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        }>;
        xPathExpressions: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
    }, "strip", z.ZodTypeAny, {
        cssSelectors: string[];
        hosting: {
            config: {} & {
                [k: string]: unknown;
            };
            write: (...args: unknown[]) => Promise<{
                value: {
                    message: string;
                    href: string;
                };
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        };
        regex: RegExp;
        synthesis: {
            config: {} & {
                [k: string]: unknown;
            };
            extension: string;
            synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
                value: import("stream").Readable;
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        };
        xPathExpressions: string[];
        audioInnerHTML?: ((args_0: string[], ...args_1: unknown[]) => string) | undefined;
    }, {
        hosting: {
            config: {} & {
                [k: string]: unknown;
            };
            write: (...args: unknown[]) => Promise<{
                value: {
                    message: string;
                    href: string;
                };
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        };
        synthesis: {
            config: {} & {
                [k: string]: unknown;
            };
            extension: string;
            synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
                value: import("stream").Readable;
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        };
        audioInnerHTML?: ((args_0: string[], ...args_1: unknown[]) => string) | undefined;
        cssSelectors?: string[] | undefined;
        regex?: RegExp | undefined;
        xPathExpressions?: string[] | undefined;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    dom: JSDOM;
    matches: {
        regex: RegExp;
        idx: number;
        matched: boolean;
    }[];
    rules: {
        cssSelectors: string[];
        hosting: {
            config: {} & {
                [k: string]: unknown;
            };
            write: (...args: unknown[]) => Promise<{
                value: {
                    message: string;
                    href: string;
                };
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        };
        regex: RegExp;
        synthesis: {
            config: {} & {
                [k: string]: unknown;
            };
            extension: string;
            synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
                value: import("stream").Readable;
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        };
        xPathExpressions: string[];
        audioInnerHTML?: ((args_0: string[], ...args_1: unknown[]) => string) | undefined;
    }[];
}, {
    dom: JSDOM;
    matches: {
        regex: RegExp;
        idx: number;
        matched: boolean;
    }[];
    rules: {
        hosting: {
            config: {} & {
                [k: string]: unknown;
            };
            write: (...args: unknown[]) => Promise<{
                value: {
                    message: string;
                    href: string;
                };
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        };
        synthesis: {
            config: {} & {
                [k: string]: unknown;
            };
            extension: string;
            synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
                value: import("stream").Readable;
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        };
        audioInnerHTML?: ((args_0: string[], ...args_1: unknown[]) => string) | undefined;
        cssSelectors?: string[] | undefined;
        regex?: RegExp | undefined;
        xPathExpressions?: string[] | undefined;
    }[];
}>;
export type Config = z.input<typeof config_schema>;
declare const match_value: z.ZodObject<z.objectUtil.extendShape<{
    text: z.ZodString;
    cssSelectors: z.ZodArray<z.ZodString, "many">;
    xPathExpressions: z.ZodArray<z.ZodString, "many">;
}, {
    audioInnerHTML: z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodString, "many">], z.ZodUnknown>, z.ZodString>;
    synthesis_configs: z.ZodArray<z.ZodObject<{
        config: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
        extension: z.ZodString;
        synthesize: z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodUnion<[z.ZodObject<{
            error: z.ZodType<Error, z.ZodTypeDef, Error>;
            value: z.ZodOptional<z.ZodUndefined>;
        }, "strip", z.ZodTypeAny, {
            error: Error;
            value?: undefined;
        }, {
            error: Error;
            value?: undefined;
        }>, z.ZodObject<{
            error: z.ZodOptional<z.ZodUndefined>;
            value: z.ZodType<import("stream").Readable, z.ZodTypeDef, import("stream").Readable>;
        }, "strip", z.ZodTypeAny, {
            value: import("stream").Readable;
            error?: undefined;
        }, {
            value: import("stream").Readable;
            error?: undefined;
        }>]>>>;
    }, "strip", z.ZodTypeAny, {
        config: {} & {
            [k: string]: unknown;
        };
        extension: string;
        synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
            value: import("stream").Readable;
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }, {
        config: {} & {
            [k: string]: unknown;
        };
        extension: string;
        synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
            value: import("stream").Readable;
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }>, "many">;
    hosting_configs: z.ZodArray<z.ZodObject<{
        config: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
        write: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodPromise<z.ZodUnion<[z.ZodObject<{
            error: z.ZodType<Error, z.ZodTypeDef, Error>;
            value: z.ZodOptional<z.ZodUndefined>;
        }, "strip", z.ZodTypeAny, {
            error: Error;
            value?: undefined;
        }, {
            error: Error;
            value?: undefined;
        }>, z.ZodObject<{
            error: z.ZodOptional<z.ZodUndefined>;
            value: z.ZodObject<{
                href: z.ZodString;
                message: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                message: string;
                href: string;
            }, {
                message: string;
                href: string;
            }>;
        }, "strip", z.ZodTypeAny, {
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        }, {
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        }>]>>>;
    }, "strip", z.ZodTypeAny, {
        config: {} & {
            [k: string]: unknown;
        };
        write: (...args: unknown[]) => Promise<{
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }, {
        config: {} & {
            [k: string]: unknown;
        };
        write: (...args: unknown[]) => Promise<{
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }>, "many">;
}>, "strip", z.ZodTypeAny, {
    audioInnerHTML: (args_0: string[], ...args_1: unknown[]) => string;
    cssSelectors: string[];
    xPathExpressions: string[];
    text: string;
    synthesis_configs: {
        config: {} & {
            [k: string]: unknown;
        };
        extension: string;
        synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
            value: import("stream").Readable;
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }[];
    hosting_configs: {
        config: {} & {
            [k: string]: unknown;
        };
        write: (...args: unknown[]) => Promise<{
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }[];
}, {
    audioInnerHTML: (args_0: string[], ...args_1: unknown[]) => string;
    cssSelectors: string[];
    xPathExpressions: string[];
    text: string;
    synthesis_configs: {
        config: {} & {
            [k: string]: unknown;
        };
        extension: string;
        synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
            value: import("stream").Readable;
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }[];
    hosting_configs: {
        config: {} & {
            [k: string]: unknown;
        };
        write: (...args: unknown[]) => Promise<{
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }[];
}>;
export type MatchValue = z.infer<typeof match_value>;
export declare const match_record: z.ZodRecord<z.ZodString, z.ZodObject<z.objectUtil.extendShape<{
    text: z.ZodString;
    cssSelectors: z.ZodArray<z.ZodString, "many">;
    xPathExpressions: z.ZodArray<z.ZodString, "many">;
}, {
    audioInnerHTML: z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodString, "many">], z.ZodUnknown>, z.ZodString>;
    synthesis_configs: z.ZodArray<z.ZodObject<{
        config: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
        extension: z.ZodString;
        synthesize: z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodUnion<[z.ZodObject<{
            error: z.ZodType<Error, z.ZodTypeDef, Error>;
            value: z.ZodOptional<z.ZodUndefined>;
        }, "strip", z.ZodTypeAny, {
            error: Error;
            value?: undefined;
        }, {
            error: Error;
            value?: undefined;
        }>, z.ZodObject<{
            error: z.ZodOptional<z.ZodUndefined>;
            value: z.ZodType<import("stream").Readable, z.ZodTypeDef, import("stream").Readable>;
        }, "strip", z.ZodTypeAny, {
            value: import("stream").Readable;
            error?: undefined;
        }, {
            value: import("stream").Readable;
            error?: undefined;
        }>]>>>;
    }, "strip", z.ZodTypeAny, {
        config: {} & {
            [k: string]: unknown;
        };
        extension: string;
        synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
            value: import("stream").Readable;
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }, {
        config: {} & {
            [k: string]: unknown;
        };
        extension: string;
        synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
            value: import("stream").Readable;
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }>, "many">;
    hosting_configs: z.ZodArray<z.ZodObject<{
        config: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
        write: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodPromise<z.ZodUnion<[z.ZodObject<{
            error: z.ZodType<Error, z.ZodTypeDef, Error>;
            value: z.ZodOptional<z.ZodUndefined>;
        }, "strip", z.ZodTypeAny, {
            error: Error;
            value?: undefined;
        }, {
            error: Error;
            value?: undefined;
        }>, z.ZodObject<{
            error: z.ZodOptional<z.ZodUndefined>;
            value: z.ZodObject<{
                href: z.ZodString;
                message: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                message: string;
                href: string;
            }, {
                message: string;
                href: string;
            }>;
        }, "strip", z.ZodTypeAny, {
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        }, {
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        }>]>>>;
    }, "strip", z.ZodTypeAny, {
        config: {} & {
            [k: string]: unknown;
        };
        write: (...args: unknown[]) => Promise<{
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }, {
        config: {} & {
            [k: string]: unknown;
        };
        write: (...args: unknown[]) => Promise<{
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }>, "many">;
}>, "strip", z.ZodTypeAny, {
    audioInnerHTML: (args_0: string[], ...args_1: unknown[]) => string;
    cssSelectors: string[];
    xPathExpressions: string[];
    text: string;
    synthesis_configs: {
        config: {} & {
            [k: string]: unknown;
        };
        extension: string;
        synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
            value: import("stream").Readable;
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }[];
    hosting_configs: {
        config: {} & {
            [k: string]: unknown;
        };
        write: (...args: unknown[]) => Promise<{
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }[];
}, {
    audioInnerHTML: (args_0: string[], ...args_1: unknown[]) => string;
    cssSelectors: string[];
    xPathExpressions: string[];
    text: string;
    synthesis_configs: {
        config: {} & {
            [k: string]: unknown;
        };
        extension: string;
        synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
            value: import("stream").Readable;
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }[];
    hosting_configs: {
        config: {} & {
            [k: string]: unknown;
        };
        write: (...args: unknown[]) => Promise<{
            value: {
                message: string;
                href: string;
            };
            error?: undefined;
        } | {
            error: Error;
            value?: undefined;
        }>;
    }[];
}>>;
export type MatchRecord = z.infer<typeof match_record>;
export declare const aggregateRules: (config: Config) => {
    error: Error;
    value?: undefined;
} | {
    value: Record<string, {
        audioInnerHTML: (args_0: string[], ...args_1: unknown[]) => string;
        cssSelectors: string[];
        xPathExpressions: string[];
        text: string;
        synthesis_configs: {
            config: {} & {
                [k: string]: unknown;
            };
            extension: string;
            synthesize: (args_0: string, ...args_1: unknown[]) => Promise<{
                value: import("stream").Readable;
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        }[];
        hosting_configs: {
            config: {} & {
                [k: string]: unknown;
            };
            write: (...args: unknown[]) => Promise<{
                value: {
                    message: string;
                    href: string;
                };
                error?: undefined;
            } | {
                error: Error;
                value?: undefined;
            }>;
        }[];
    }>;
    error?: undefined;
};
export {};
//# sourceMappingURL=aggregate-rules.d.ts.map