import { z } from "zod";
export declare const cardTools: {
    findCards: {
        description: string;
        schema: z.ZodObject<{
            query: z.ZodString;
            offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
            limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
        }, "strip", z.ZodTypeAny, {
            query: string;
            offset: number;
            limit: number;
        }, {
            query: string;
            offset?: number | undefined;
            limit?: number | undefined;
        }>;
        handler: ({ query, offset, limit }: {
            query: string;
            offset?: number;
            limit?: number;
        }) => Promise<{
            cards: number[];
            pagination: {
                offset: number;
                limit: number;
                total: number;
                hasMore: boolean;
                nextOffset: number | null;
            };
        }>;
    };
    getNextCards: {
        description: string;
        schema: z.ZodObject<{
            deck: z.ZodOptional<z.ZodString>;
            limit: z.ZodDefault<z.ZodNumber>;
            offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        }, "strip", z.ZodTypeAny, {
            limit: number;
            deck?: string | undefined;
            offset?: number | undefined;
        }, {
            deck?: string | undefined;
            offset?: number | undefined;
            limit?: number | undefined;
        }>;
        handler: ({ deck, limit, offset }: {
            deck?: string;
            limit: number;
            offset?: number;
        }) => Promise<{
            cards: never[];
            message: string;
            pagination: {
                offset: number;
                limit: number;
                total: number;
                hasMore: boolean;
                nextOffset?: undefined;
            };
            breakdown?: undefined;
            queueOrder?: undefined;
        } | {
            cards: {
                cardId: number;
                queue: number;
                interval: number;
                due: number;
                reps: number;
                factor: number;
                fields?: Record<string, {
                    value: string;
                }>;
            }[];
            breakdown: {
                learning: number;
                review: number;
                new: number;
            };
            pagination: {
                offset: number;
                limit: number;
                total: number;
                hasMore: boolean;
                nextOffset: number | null;
            };
            queueOrder: string;
            message?: undefined;
        }>;
    };
    cardsInfo: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
        }, {
            cards: (string | number)[];
        }>;
        handler: ({ cards }: {
            cards: Array<number | string>;
        }) => Promise<{
            cardId: number;
            queue: number;
            interval: number;
            due: number;
            reps: number;
            factor: number;
            fields?: Record<string, {
                value: string;
            }>;
        }[] | {
            cards: {
                cardId: number;
                queue: number;
                interval: number;
                due: number;
                reps: number;
                factor: number;
                fields?: Record<string, {
                    value: string;
                }>;
            }[];
            metadata: {
                total: number;
                batches: number;
                batchSize: number;
            };
        }>;
    };
    suspend: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
        }, {
            cards: (string | number)[];
        }>;
        handler: ({ cards }: {
            cards: Array<number | string>;
        }) => Promise<true>;
    };
    unsuspend: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
        }, {
            cards: (string | number)[];
        }>;
        handler: ({ cards }: {
            cards: Array<number | string>;
        }) => Promise<true>;
    };
    getEaseFactors: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
        }, {
            cards: (string | number)[];
        }>;
        handler: ({ cards }: {
            cards: Array<number | string>;
        }) => Promise<number[]>;
    };
    setEaseFactors: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
            easeFactors: z.ZodArray<z.ZodNumber, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
            easeFactors: number[];
        }, {
            cards: (string | number)[];
            easeFactors: number[];
        }>;
        handler: ({ cards, easeFactors }: {
            cards: Array<number | string>;
            easeFactors: number[];
        }) => Promise<true>;
    };
    canAddNotes: {
        description: string;
        schema: z.ZodObject<{
            notes: z.ZodArray<z.ZodObject<{
                deckName: z.ZodString;
                modelName: z.ZodString;
                fields: z.ZodRecord<z.ZodString, z.ZodString>;
                tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            }, "strip", z.ZodTypeAny, {
                deckName: string;
                modelName: string;
                fields: Record<string, string>;
                tags?: string[] | undefined;
            }, {
                deckName: string;
                modelName: string;
                fields: Record<string, string>;
                tags?: string[] | undefined;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            notes: {
                deckName: string;
                modelName: string;
                fields: Record<string, string>;
                tags?: string[] | undefined;
            }[];
        }, {
            notes: {
                deckName: string;
                modelName: string;
                fields: Record<string, string>;
                tags?: string[] | undefined;
            }[];
        }>;
        handler: ({ notes, }: {
            notes: Array<{
                deckName: string;
                modelName: string;
                fields: Record<string, string>;
                tags?: string[];
            }>;
        }) => Promise<boolean[]>;
    };
    areSuspended: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
        }, {
            cards: (string | number)[];
        }>;
        handler: ({ cards }: {
            cards: Array<number | string>;
        }) => Promise<boolean[]>;
    };
    areDue: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
        }, {
            cards: (string | number)[];
        }>;
        handler: ({ cards }: {
            cards: Array<number | string>;
        }) => Promise<boolean[]>;
    };
    getIntervals: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
            complete: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
            complete?: boolean | undefined;
        }, {
            cards: (string | number)[];
            complete?: boolean | undefined;
        }>;
        handler: ({ cards, complete }: {
            cards: Array<number | string>;
            complete?: boolean;
        }) => Promise<number[]>;
    };
    cardsToNotes: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
        }, {
            cards: (string | number)[];
        }>;
        handler: ({ cards }: {
            cards: Array<number | string>;
        }) => Promise<number[]>;
    };
    cardsModTime: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
        }, {
            cards: (string | number)[];
        }>;
        handler: ({ cards }: {
            cards: Array<number | string>;
        }) => Promise<number[]>;
    };
    answerCards: {
        description: string;
        schema: z.ZodObject<{
            answers: z.ZodArray<z.ZodObject<{
                cardId: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
                ease: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                cardId: string | number;
                ease: number;
            }, {
                cardId: string | number;
                ease: number;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            answers: {
                cardId: string | number;
                ease: number;
            }[];
        }, {
            answers: {
                cardId: string | number;
                ease: number;
            }[];
        }>;
        handler: ({ answers }: {
            answers: Array<{
                cardId: number | string;
                ease: number;
            }>;
        }) => Promise<boolean[]>;
    };
    forgetCards: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
        }, {
            cards: (string | number)[];
        }>;
        handler: ({ cards }: {
            cards: Array<number | string>;
        }) => Promise<true>;
    };
    relearnCards: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
        }, {
            cards: (string | number)[];
        }>;
        handler: ({ cards }: {
            cards: Array<number | string>;
        }) => Promise<true>;
    };
    setSpecificValueOfCard: {
        description: string;
        schema: z.ZodObject<{
            card: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            keys: z.ZodArray<z.ZodString, "many">;
            newValues: z.ZodArray<z.ZodString, "many">;
            warningCheck: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            keys: string[];
            card: string | number;
            newValues: string[];
            warningCheck?: boolean | undefined;
        }, {
            keys: string[];
            card: string | number;
            newValues: string[];
            warningCheck?: boolean | undefined;
        }>;
        handler: ({ card, keys, newValues, warningCheck, }: {
            card: number | string;
            keys: string[];
            newValues: string[];
            warningCheck?: boolean;
        }) => Promise<true>;
    };
    getDecks: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
        }, "strip", z.ZodTypeAny, {
            cards: (string | number)[];
        }, {
            cards: (string | number)[];
        }>;
        handler: ({ cards }: {
            cards: Array<number | string>;
        }) => Promise<string[]>;
    };
    changeDeck: {
        description: string;
        schema: z.ZodObject<{
            cards: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString]>, "many">;
            deck: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            deck: string;
            cards: (string | number)[];
        }, {
            deck: string;
            cards: (string | number)[];
        }>;
        handler: ({ cards, deck }: {
            cards: Array<number | string>;
            deck: string;
        }) => Promise<true>;
    };
};
//# sourceMappingURL=cards.d.ts.map