import { RawBodyRequest } from '@nestjs/common';
import { Request } from 'express';
import { FeesService } from './fees.service';
import { CreateFeeStructureDto } from './dto/create-fee-structure.dto';
import { UpdateFeeStructureDto } from './dto/update-fee-structure.dto';
import { RecordPaymentDto } from './dto/record-payment.dto';
import { FilterAssignmentsDto } from './dto/filter-assignments.dto';
import { VerifyFeePaymentDto } from './dto/verify-fee-payment.dto';
import { CreateOrderDto } from './dto/create-order.dto';
import { DuplicateFeeStructureDto } from './dto/duplicate-fee-structure.dto';
import { ApplyDiscountDto } from './dto/apply-discount.dto';
import { UpdateDiscountDto } from './dto/update-discount.dto';
export declare class FeesController {
    private readonly feesService;
    constructor(feesService: FeesService);
    createStructure(dto: CreateFeeStructureDto): Promise<{
        assignmentStats: {
            docsCreated: number;
            studentCount: number;
        };
        name: string;
        feeType: "one-time" | "monthly" | "quarterly" | "yearly";
        academicYearId: string;
        amount: number;
        classIds: string[];
        dueMonth: number;
        dueDay: number;
        startDate?: Date;
        endDate?: Date;
        enableSubFees: boolean;
        subFees: import("./schemas/fee-structure.schema").SubFee[];
        lateFine: {
            enabled: boolean;
            type: "percentage" | "per_day" | "day_wise_slab";
            amountPerDay: number;
            percentage: number;
            slabs: {
                startDay: number;
                endDay: number;
                amount: number;
            }[];
        };
        isActive: boolean;
        _id: string;
        __v: number;
        createdAt?: Date;
        updatedAt?: Date;
        $locals: Record<string, unknown>;
        $op: "save" | "validate" | "remove" | null;
        $where: Record<string, unknown>;
        baseModelName?: string;
        collection: import("mongoose").Collection;
        db: import("mongoose").Connection;
        errors?: import("mongoose").Error.ValidationError;
        id?: any;
        isNew: boolean;
        schema: import("mongoose").Schema;
    }>;
    getStructures(academicYearId?: string, classId?: string, activeOnly?: string, ayHeader?: string): Promise<(import("mongoose").FlattenMaps<import("./schemas/fee-structure.schema").FeeStructureDocument> & Required<{
        _id: string;
    }>)[]>;
    duplicateStructure(id: string, dto: DuplicateFeeStructureDto): Promise<{
        structure: import("./schemas/fee-structure.schema").FeeStructure & import("mongoose").Document<unknown, any, any, Record<string, any>> & Required<{
            _id: string;
        }>;
        assignmentsGenerated: number;
        studentCount: number;
    }>;
    getStructure(id: string): Promise<import("mongoose").FlattenMaps<import("./schemas/fee-structure.schema").FeeStructureDocument> & Required<{
        _id: string;
    }>>;
    updateStructure(id: string, dto: UpdateFeeStructureDto): Promise<import("mongoose").FlattenMaps<import("./schemas/fee-structure.schema").FeeStructureDocument> & Required<{
        _id: string;
    }>>;
    deleteStructure(id: string): Promise<{
        deleted: boolean;
    }>;
    regenerateUnpaid(id: string): Promise<{
        generated: number;
        updated: number;
        studentCount: number;
        deletedOld: number;
    }>;
    getAssignments(filter: FilterAssignmentsDto, ayHeader?: string): Promise<any[]>;
    syncAssignments(structureId?: string, ayHeader?: string): Promise<{
        synced: number;
        studentCount: number;
    }>;
    applyDiscount(id: string, dto: ApplyDiscountDto, adminId: string): Promise<any>;
    updateDiscount(id: string, dto: UpdateDiscountDto, adminId: string): Promise<any>;
    removeDiscount(id: string): Promise<any>;
    recordOfflinePayment(id: string, dto: RecordPaymentDto, adminId: string, receipt?: Express.Multer.File): Promise<{
        receiptNumber: any;
        payment: any;
        invoiceWarning: string | null;
        studentId: string;
        feeStructureId: string;
        academicYearId: string;
        classId: string;
        feeName: string;
        installment: string;
        amount: number;
        baseAmount: number;
        subFees: import("mongoose").FlattenMaps<import("./schemas/fee-structure.schema").SubFee>[];
        fineAmount: number;
        paidAmount: number;
        dueDate: Date;
        status: "pending" | "partial" | "paid";
        discountType?: "amount" | "percentage" | undefined;
        discountValue?: number | undefined;
        discountAmount: number;
        discountReason?: string | undefined;
        discountValidUntil?: Date | undefined;
        discountAppliedBy?: string | undefined;
        paidAt?: Date | undefined;
        paymentMethod?: string | undefined;
        razorpayOrderId?: string | undefined;
        razorpayPaymentId?: string | undefined;
        razorpaySignature?: string | undefined;
        razorpayOrderAmount?: number | undefined;
        collectedBy?: string | undefined;
        notes?: string | undefined;
        transactionId?: string | undefined;
        _id: string;
        __v: number;
        createdAt?: Date | undefined;
        updatedAt?: Date | undefined;
        $assertPopulated: <Paths = {}>(path: string | string[], values?: Partial<Paths> | undefined) => Omit<import("./schemas/fee-assignment.schema").FeeAssignmentDocument, keyof Paths> & Paths;
        $clearModifiedPaths: () => import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
        $clone: () => import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
        $createModifiedPathsSnapshot: () => import("mongoose").ModifiedPathsSnapshot;
        $getAllSubdocs: () => import("mongoose").Document[];
        $ignore: (path: string) => void;
        $isDefault: (path: string) => boolean;
        $isDeleted: (val?: boolean) => boolean;
        $getPopulatedDocs: () => import("mongoose").Document[];
        $inc: (path: string | string[], val?: number) => import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
        $isEmpty: (path: string) => boolean;
        $isValid: (path: string) => boolean;
        $locals: import("mongoose").FlattenMaps<Record<string, unknown>>;
        $markValid: (path: string) => void;
        $model: {
            <ModelType = import("mongoose").Model<unknown, {}, {}, {}, import("mongoose").Document<unknown, {}, unknown, {}> & {
                _id: import("mongoose").Types.ObjectId;
            } & {
                __v: number;
            }, any>>(name: string): ModelType;
            <ModelType = import("mongoose").Model<any, {}, {}, {}, any, any>>(): ModelType;
        };
        $op: "save" | "validate" | "remove" | null;
        $restoreModifiedPathsSnapshot: (snapshot: import("mongoose").ModifiedPathsSnapshot) => import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
        $session: (session?: import("mongoose").ClientSession | null) => import("mongoose").ClientSession | null;
        $set: {
            (path: string | Record<string, any>, val: any, type: any, options?: import("mongoose").DocumentSetOptions): import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
            (path: string | Record<string, any>, val: any, options?: import("mongoose").DocumentSetOptions): import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
            (value: string | Record<string, any>): import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
        };
        $where: import("mongoose").FlattenMaps<Record<string, unknown>>;
        baseModelName?: string | undefined;
        collection: import("mongoose").Collection;
        db: import("mongoose").FlattenMaps<import("mongoose").Connection>;
        deleteOne: (options?: import("mongoose").QueryOptions) => any;
        depopulate: <Paths = {}>(path?: string | string[]) => import("mongoose").MergeType<import("./schemas/fee-assignment.schema").FeeAssignmentDocument, Paths>;
        directModifiedPaths: () => Array<string>;
        equals: (doc: import("mongoose").Document<unknown, any, any, Record<string, any>>) => boolean;
        errors?: import("mongoose").Error.ValidationError | undefined;
        get: {
            <T extends string | number | symbol>(path: T, type?: any, options?: any): any;
            (path: string, type?: any, options?: any): any;
        };
        getChanges: () => import("mongoose").UpdateQuery<import("./schemas/fee-assignment.schema").FeeAssignmentDocument>;
        id?: any;
        increment: () => import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
        init: (obj: import("mongoose").AnyObject, opts?: import("mongoose").AnyObject) => import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
        invalidate: {
            <T extends string | number | symbol>(path: T, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
            (path: string, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
        };
        isDirectModified: {
            <T extends string | number | symbol>(path: T | T[]): boolean;
            (path: string | Array<string>): boolean;
        };
        isDirectSelected: {
            <T extends string | number | symbol>(path: T): boolean;
            (path: string): boolean;
        };
        isInit: {
            <T extends string | number | symbol>(path: T): boolean;
            (path: string): boolean;
        };
        isModified: {
            <T extends string | number | symbol>(path?: T | T[] | undefined, options?: {
                ignoreAtomics?: boolean;
            } | null): boolean;
            (path?: string | Array<string>, options?: {
                ignoreAtomics?: boolean;
            } | null): boolean;
        };
        isNew: boolean;
        isSelected: {
            <T extends string | number | symbol>(path: T): boolean;
            (path: string): boolean;
        };
        markModified: {
            <T extends string | number | symbol>(path: T, scope?: any): void;
            (path: string, scope?: any): void;
        };
        model: {
            <ModelType = import("mongoose").Model<unknown, {}, {}, {}, import("mongoose").Document<unknown, {}, unknown, {}> & {
                _id: import("mongoose").Types.ObjectId;
            } & {
                __v: number;
            }, any>>(name: string): ModelType;
            <ModelType = import("mongoose").Model<any, {}, {}, {}, any, any>>(): ModelType;
        };
        modifiedPaths: (options?: {
            includeChildren?: boolean;
        }) => Array<string>;
        overwrite: (obj: import("mongoose").AnyObject) => import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
        $parent: () => import("mongoose").Document | undefined;
        populate: {
            <Paths = {}>(path: string | import("mongoose").PopulateOptions | (string | import("mongoose").PopulateOptions)[]): Promise<import("mongoose").MergeType<import("./schemas/fee-assignment.schema").FeeAssignmentDocument, Paths>>;
            <Paths = {}>(path: string, select?: string | import("mongoose").AnyObject, model?: import("mongoose").Model<any>, match?: import("mongoose").AnyObject, options?: import("mongoose").PopulateOptions): Promise<import("mongoose").MergeType<import("./schemas/fee-assignment.schema").FeeAssignmentDocument, Paths>>;
        };
        populated: (path: string) => any;
        replaceOne: (replacement?: import("mongoose").AnyObject, options?: import("mongoose").QueryOptions | null) => import("mongoose").Query<any, import("./schemas/fee-assignment.schema").FeeAssignmentDocument, {}, unknown, "find", Record<string, never>>;
        save: (options?: import("mongoose").SaveOptions) => Promise<import("./schemas/fee-assignment.schema").FeeAssignmentDocument>;
        schema: import("mongoose").FlattenMaps<import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
            [x: string]: unknown;
        }, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
            [x: string]: unknown;
        }>, {}> & import("mongoose").FlatRecord<{
            [x: string]: unknown;
        }> & Required<{
            _id: unknown;
        }> & {
            __v: number;
        }>>;
        set: {
            <T extends string | number | symbol>(path: T, val: any, type: any, options?: import("mongoose").DocumentSetOptions): import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
            (path: string | Record<string, any>, val: any, type: any, options?: import("mongoose").DocumentSetOptions): import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
            (path: string | Record<string, any>, val: any, options?: import("mongoose").DocumentSetOptions): import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
            (value: string | Record<string, any>): import("./schemas/fee-assignment.schema").FeeAssignmentDocument;
        };
        toJSON: {
            (options: import("mongoose").ToObjectOptions & {
                virtuals: true;
            }): any;
            (options?: import("mongoose").ToObjectOptions & {
                flattenMaps?: true;
                flattenObjectIds?: false;
            }): import("mongoose").FlattenMaps<any>;
            (options: import("mongoose").ToObjectOptions & {
                flattenObjectIds: false;
            }): import("mongoose").FlattenMaps<any>;
            (options: import("mongoose").ToObjectOptions & {
                flattenObjectIds: true;
            }): {
                [x: string]: any;
            };
            (options: import("mongoose").ToObjectOptions & {
                flattenMaps: false;
            }): any;
            (options: import("mongoose").ToObjectOptions & {
                flattenMaps: false;
                flattenObjectIds: true;
            }): any;
            <T = any>(options?: import("mongoose").ToObjectOptions & {
                flattenMaps?: true;
                flattenObjectIds?: false;
            }): import("mongoose").FlattenMaps<T>;
            <T = any>(options: import("mongoose").ToObjectOptions & {
                flattenObjectIds: false;
            }): import("mongoose").FlattenMaps<T>;
            <T = any>(options: import("mongoose").ToObjectOptions & {
                flattenObjectIds: true;
            }): import("mongoose").ObjectIdToString<import("mongoose").FlattenMaps<T>>;
            <T = any>(options: import("mongoose").ToObjectOptions & {
                flattenMaps: false;
            }): T;
            <T = any>(options: import("mongoose").ToObjectOptions & {
                flattenMaps: false;
                flattenObjectIds: true;
            }): import("mongoose").ObjectIdToString<T>;
        };
        toObject: {
            (options: import("mongoose").ToObjectOptions & {
                virtuals: true;
            }): any;
            (options?: import("mongoose").ToObjectOptions): any;
            <T>(options?: import("mongoose").ToObjectOptions): import("mongoose").Default__v<import("mongoose").Require_id<T>>;
        };
        unmarkModified: {
            <T extends string | number | symbol>(path: T): void;
            (path: string): void;
        };
        updateOne: (update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<import("./schemas/fee-assignment.schema").FeeAssignmentDocument> | undefined, options?: import("mongoose").QueryOptions | null) => import("mongoose").Query<any, import("./schemas/fee-assignment.schema").FeeAssignmentDocument, {}, unknown, "find", Record<string, never>>;
        validate: {
            <T extends string | number | symbol>(pathsToValidate?: T | T[] | undefined, options?: import("mongoose").AnyObject): Promise<void>;
            (pathsToValidate?: import("mongoose").pathsToValidate, options?: import("mongoose").AnyObject): Promise<void>;
            (options: {
                pathsToSkip?: import("mongoose").pathsToSkip;
            }): Promise<void>;
        };
        validateSync: {
            (options: {
                pathsToSkip?: import("mongoose").pathsToSkip;
                [k: string]: any;
            }): import("mongoose").Error.ValidationError | null;
            <T extends string | number | symbol>(pathsToValidate?: T | T[] | undefined, options?: import("mongoose").AnyObject): import("mongoose").Error.ValidationError | null;
            (pathsToValidate?: import("mongoose").pathsToValidate, options?: import("mongoose").AnyObject): import("mongoose").Error.ValidationError | null;
        };
    }>;
    getStudentDashboardAdmin(studentId: string, academicYearId?: string, ayHeader?: string): Promise<{
        student: import("mongoose").FlattenMaps<import("../students/schemas/student.schema").StudentDocument> & Required<{
            _id: string;
        }>;
        summary: {
            totalFee: any;
            totalDiscount: any;
            paidAmount: any;
            dueAmount: number;
            nextDueDate: string | null;
        };
        assignments: any[];
    }>;
    getMyDashboard(studentId: string, academicYearId?: string, ayHeader?: string): Promise<{
        student: import("mongoose").FlattenMaps<import("../students/schemas/student.schema").StudentDocument> & Required<{
            _id: string;
        }>;
        summary: {
            totalFee: any;
            totalDiscount: any;
            paidAmount: any;
            dueAmount: number;
            nextDueDate: string | null;
        };
        assignments: any[];
    }>;
    createOrder(id: string, studentId: string, dto: CreateOrderDto): Promise<{
        orderId: string;
        amount: string | number;
        currency: string;
        keyId: string;
        assignmentId: string;
    }>;
    verifyPayment(id: string, studentId: string, body: VerifyFeePaymentDto): Promise<{
        status: string;
        receiptNumber: string | undefined;
    } | {
        status: "partial" | "pending" | "paid";
        receiptNumber: any;
    }>;
    getPaymentHistory(id: string, userId: string, role: string): Promise<{
        collectedByName: string | undefined;
        receiptUrl: string | undefined;
        assignmentId: string;
        studentId: string;
        academicYearId: string;
        amount: number;
        fineComponent: number;
        paymentMethod: string;
        receiptNumber?: string | undefined;
        razorpayOrderId?: string | undefined;
        razorpayPaymentId?: string | undefined;
        razorpaySignature?: string | undefined;
        transactionId?: string | undefined;
        collectedBy?: string | undefined;
        notes?: string | undefined;
        paidAt: Date;
        _id: string;
        __v: number;
        createdAt?: Date | undefined;
        updatedAt?: Date | undefined;
        $assertPopulated: <Paths = {}>(path: string | string[], values?: Partial<Paths> | undefined) => Omit<import("./schemas/fee-payment.schema").FeePaymentDocument, keyof Paths> & Paths;
        $clearModifiedPaths: () => import("./schemas/fee-payment.schema").FeePaymentDocument;
        $clone: () => import("./schemas/fee-payment.schema").FeePaymentDocument;
        $createModifiedPathsSnapshot: () => import("mongoose").ModifiedPathsSnapshot;
        $getAllSubdocs: () => import("mongoose").Document[];
        $ignore: (path: string) => void;
        $isDefault: (path: string) => boolean;
        $isDeleted: (val?: boolean) => boolean;
        $getPopulatedDocs: () => import("mongoose").Document[];
        $inc: (path: string | string[], val?: number) => import("./schemas/fee-payment.schema").FeePaymentDocument;
        $isEmpty: (path: string) => boolean;
        $isValid: (path: string) => boolean;
        $locals: import("mongoose").FlattenMaps<Record<string, unknown>>;
        $markValid: (path: string) => void;
        $model: {
            <ModelType = import("mongoose").Model<unknown, {}, {}, {}, import("mongoose").Document<unknown, {}, unknown, {}> & {
                _id: import("mongoose").Types.ObjectId;
            } & {
                __v: number;
            }, any>>(name: string): ModelType;
            <ModelType = import("mongoose").Model<any, {}, {}, {}, any, any>>(): ModelType;
        };
        $op: "save" | "validate" | "remove" | null;
        $restoreModifiedPathsSnapshot: (snapshot: import("mongoose").ModifiedPathsSnapshot) => import("./schemas/fee-payment.schema").FeePaymentDocument;
        $session: (session?: import("mongoose").ClientSession | null) => import("mongoose").ClientSession | null;
        $set: {
            (path: string | Record<string, any>, val: any, type: any, options?: import("mongoose").DocumentSetOptions): import("./schemas/fee-payment.schema").FeePaymentDocument;
            (path: string | Record<string, any>, val: any, options?: import("mongoose").DocumentSetOptions): import("./schemas/fee-payment.schema").FeePaymentDocument;
            (value: string | Record<string, any>): import("./schemas/fee-payment.schema").FeePaymentDocument;
        };
        $where: import("mongoose").FlattenMaps<Record<string, unknown>>;
        baseModelName?: string | undefined;
        collection: import("mongoose").Collection;
        db: import("mongoose").FlattenMaps<import("mongoose").Connection>;
        deleteOne: (options?: import("mongoose").QueryOptions) => any;
        depopulate: <Paths = {}>(path?: string | string[]) => import("mongoose").MergeType<import("./schemas/fee-payment.schema").FeePaymentDocument, Paths>;
        directModifiedPaths: () => Array<string>;
        equals: (doc: import("mongoose").Document<unknown, any, any, Record<string, any>>) => boolean;
        errors?: import("mongoose").Error.ValidationError | undefined;
        get: {
            <T extends string | number | symbol>(path: T, type?: any, options?: any): any;
            (path: string, type?: any, options?: any): any;
        };
        getChanges: () => import("mongoose").UpdateQuery<import("./schemas/fee-payment.schema").FeePaymentDocument>;
        id?: any;
        increment: () => import("./schemas/fee-payment.schema").FeePaymentDocument;
        init: (obj: import("mongoose").AnyObject, opts?: import("mongoose").AnyObject) => import("./schemas/fee-payment.schema").FeePaymentDocument;
        invalidate: {
            <T extends string | number | symbol>(path: T, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
            (path: string, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
        };
        isDirectModified: {
            <T extends string | number | symbol>(path: T | T[]): boolean;
            (path: string | Array<string>): boolean;
        };
        isDirectSelected: {
            <T extends string | number | symbol>(path: T): boolean;
            (path: string): boolean;
        };
        isInit: {
            <T extends string | number | symbol>(path: T): boolean;
            (path: string): boolean;
        };
        isModified: {
            <T extends string | number | symbol>(path?: T | T[] | undefined, options?: {
                ignoreAtomics?: boolean;
            } | null): boolean;
            (path?: string | Array<string>, options?: {
                ignoreAtomics?: boolean;
            } | null): boolean;
        };
        isNew: boolean;
        isSelected: {
            <T extends string | number | symbol>(path: T): boolean;
            (path: string): boolean;
        };
        markModified: {
            <T extends string | number | symbol>(path: T, scope?: any): void;
            (path: string, scope?: any): void;
        };
        model: {
            <ModelType = import("mongoose").Model<unknown, {}, {}, {}, import("mongoose").Document<unknown, {}, unknown, {}> & {
                _id: import("mongoose").Types.ObjectId;
            } & {
                __v: number;
            }, any>>(name: string): ModelType;
            <ModelType = import("mongoose").Model<any, {}, {}, {}, any, any>>(): ModelType;
        };
        modifiedPaths: (options?: {
            includeChildren?: boolean;
        }) => Array<string>;
        overwrite: (obj: import("mongoose").AnyObject) => import("./schemas/fee-payment.schema").FeePaymentDocument;
        $parent: () => import("mongoose").Document | undefined;
        populate: {
            <Paths = {}>(path: string | import("mongoose").PopulateOptions | (string | import("mongoose").PopulateOptions)[]): Promise<import("mongoose").MergeType<import("./schemas/fee-payment.schema").FeePaymentDocument, Paths>>;
            <Paths = {}>(path: string, select?: string | import("mongoose").AnyObject, model?: import("mongoose").Model<any>, match?: import("mongoose").AnyObject, options?: import("mongoose").PopulateOptions): Promise<import("mongoose").MergeType<import("./schemas/fee-payment.schema").FeePaymentDocument, Paths>>;
        };
        populated: (path: string) => any;
        replaceOne: (replacement?: import("mongoose").AnyObject, options?: import("mongoose").QueryOptions | null) => import("mongoose").Query<any, import("./schemas/fee-payment.schema").FeePaymentDocument, {}, unknown, "find", Record<string, never>>;
        save: (options?: import("mongoose").SaveOptions) => Promise<import("./schemas/fee-payment.schema").FeePaymentDocument>;
        schema: import("mongoose").FlattenMaps<import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
            [x: string]: unknown;
        }, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
            [x: string]: unknown;
        }>, {}> & import("mongoose").FlatRecord<{
            [x: string]: unknown;
        }> & Required<{
            _id: unknown;
        }> & {
            __v: number;
        }>>;
        set: {
            <T extends string | number | symbol>(path: T, val: any, type: any, options?: import("mongoose").DocumentSetOptions): import("./schemas/fee-payment.schema").FeePaymentDocument;
            (path: string | Record<string, any>, val: any, type: any, options?: import("mongoose").DocumentSetOptions): import("./schemas/fee-payment.schema").FeePaymentDocument;
            (path: string | Record<string, any>, val: any, options?: import("mongoose").DocumentSetOptions): import("./schemas/fee-payment.schema").FeePaymentDocument;
            (value: string | Record<string, any>): import("./schemas/fee-payment.schema").FeePaymentDocument;
        };
        toJSON: {
            (options: import("mongoose").ToObjectOptions & {
                virtuals: true;
            }): any;
            (options?: import("mongoose").ToObjectOptions & {
                flattenMaps?: true;
                flattenObjectIds?: false;
            }): import("mongoose").FlattenMaps<any>;
            (options: import("mongoose").ToObjectOptions & {
                flattenObjectIds: false;
            }): import("mongoose").FlattenMaps<any>;
            (options: import("mongoose").ToObjectOptions & {
                flattenObjectIds: true;
            }): {
                [x: string]: any;
            };
            (options: import("mongoose").ToObjectOptions & {
                flattenMaps: false;
            }): any;
            (options: import("mongoose").ToObjectOptions & {
                flattenMaps: false;
                flattenObjectIds: true;
            }): any;
            <T = any>(options?: import("mongoose").ToObjectOptions & {
                flattenMaps?: true;
                flattenObjectIds?: false;
            }): import("mongoose").FlattenMaps<T>;
            <T = any>(options: import("mongoose").ToObjectOptions & {
                flattenObjectIds: false;
            }): import("mongoose").FlattenMaps<T>;
            <T = any>(options: import("mongoose").ToObjectOptions & {
                flattenObjectIds: true;
            }): import("mongoose").ObjectIdToString<import("mongoose").FlattenMaps<T>>;
            <T = any>(options: import("mongoose").ToObjectOptions & {
                flattenMaps: false;
            }): T;
            <T = any>(options: import("mongoose").ToObjectOptions & {
                flattenMaps: false;
                flattenObjectIds: true;
            }): import("mongoose").ObjectIdToString<T>;
        };
        toObject: {
            (options: import("mongoose").ToObjectOptions & {
                virtuals: true;
            }): any;
            (options?: import("mongoose").ToObjectOptions): any;
            <T>(options?: import("mongoose").ToObjectOptions): import("mongoose").Default__v<import("mongoose").Require_id<T>>;
        };
        unmarkModified: {
            <T extends string | number | symbol>(path: T): void;
            (path: string): void;
        };
        updateOne: (update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery<import("./schemas/fee-payment.schema").FeePaymentDocument> | undefined, options?: import("mongoose").QueryOptions | null) => import("mongoose").Query<any, import("./schemas/fee-payment.schema").FeePaymentDocument, {}, unknown, "find", Record<string, never>>;
        validate: {
            <T extends string | number | symbol>(pathsToValidate?: T | T[] | undefined, options?: import("mongoose").AnyObject): Promise<void>;
            (pathsToValidate?: import("mongoose").pathsToValidate, options?: import("mongoose").AnyObject): Promise<void>;
            (options: {
                pathsToSkip?: import("mongoose").pathsToSkip;
            }): Promise<void>;
        };
        validateSync: {
            (options: {
                pathsToSkip?: import("mongoose").pathsToSkip;
                [k: string]: any;
            }): import("mongoose").Error.ValidationError | null;
            <T extends string | number | symbol>(pathsToValidate?: T | T[] | undefined, options?: import("mongoose").AnyObject): import("mongoose").Error.ValidationError | null;
            (pathsToValidate?: import("mongoose").pathsToValidate, options?: import("mongoose").AnyObject): import("mongoose").Error.ValidationError | null;
        };
    }[]>;
    verifyReceipt(receipt: string): Promise<{
        receiptNumber: string | undefined;
        studentName: string;
        studentId: string;
        rollNumber: string;
        feeName: string;
        installment: string;
        amount: number;
        fineComponent: number;
        totalPaid: number;
        status: string;
        paidAt: Date;
        paymentMethod: string;
        fineAmount?: undefined;
        discountAmount?: undefined;
    } | {
        receiptNumber: string | undefined;
        studentName: string;
        studentId: string;
        rollNumber: string;
        feeName: string;
        installment: string;
        amount: number;
        fineAmount: number;
        discountAmount: number;
        totalPaid: number;
        status: "partial" | "pending" | "paid";
        paidAt: Date | undefined;
        paymentMethod: string | undefined;
        fineComponent?: undefined;
    }>;
    handleWebhook(req: RawBodyRequest<Request>): Promise<{
        received: boolean;
    }>;
}
