import * as I from './membership.interface';
import { Ref } from '@typegoose/typegoose';
import { Restaurant, Business } from '~backend/business/business.model';
import { FreeCreditOption, RawEffect, Voucher } from '../marketing.model';
import { Types } from 'mongoose';
import { MemberCreditBalance } from '~backend/marketing/credit/credit.model';
import { StoreOption } from '../store/store.model';
import { ORDER_TYPE } from '~backend/order/order.interface';
export declare class MembershipTitle implements I.Title.Title {
    _id: Types.ObjectId;
    get id(): string;
    image?: string;
    name: string;
    internal: boolean;
}
export declare namespace Title {
    class MembershipTitleDto implements I.Title.Title {
        id: string;
        image?: string;
        name: string;
        internal: boolean;
    }
}
export declare namespace Benefit {
    export class BaseOption implements I.Benefit.BaseOption {
        type: I.Benefit.Type;
    }
    export namespace Triggerer {
        class BaseBirthdayOption implements I.Benefit.Triggerer.BaseBirthdayOption {
            type: I.Benefit.Triggerer.BirthdayType;
        }
        class BirthdayBeforeOption extends BaseBirthdayOption implements I.Benefit.Triggerer.BirthdayBeforeOption {
            type: I.Benefit.Triggerer.BirthdayType.before;
            day: number;
        }
        class BirthdayStartOfOption extends BaseBirthdayOption implements I.Benefit.Triggerer.BirthdayStartOfOption {
            type: I.Benefit.Triggerer.BirthdayType.startOf;
            unit: I.Benefit.Triggerer.TimeUnit;
        }
        class BaseTriggerer implements I.Benefit.Triggerer.BaseTriggerer {
            type: I.Benefit.Triggerer.Type;
        }
        class BirthdayTriggerer extends BaseTriggerer implements I.Benefit.Triggerer.BirthdayTriggerer {
            type: I.Benefit.Triggerer.Type.birthday;
            option: BirthdayBeforeOption | BirthdayStartOfOption;
        }
        class CronTriggerer extends BaseTriggerer implements I.Benefit.Triggerer.CronTriggerer {
            type: I.Benefit.Triggerer.Type.cron;
            cron: string;
        }
    }
    class Duration implements I.Benefit.Duration {
        start: string;
        end: string;
    }
    export class Scheduler implements I.Benefit.Scheduler {
        start: Triggerer.CronTriggerer | Triggerer.BirthdayTriggerer;
        validity: number;
        timePeriod: Duration[];
    }
    export class BasicOption extends BaseOption implements I.Benefit.BasicOption {
        type: I.Benefit.Type.basic;
        effect: RawEffect;
        scheduler: Scheduler;
    }
    export class ScheduleOption extends BaseOption implements I.Benefit.ScheduleOption {
        type: I.Benefit.Type.schedule;
        vouchers: Ref<Voucher>[];
        triggerer: Triggerer.CronTriggerer | Triggerer.BirthdayTriggerer;
        distributedAt: Date;
        freeCredit?: FreeCreditOption;
    }
    export class Benefit implements I.Benefit.Benefit {
        _id: Types.ObjectId;
        get id(): any;
        _clientRequest: {
            date: Date;
            restaurantId?: string;
            orderType?: ORDER_TYPE;
            level: number;
            birthday?: Date;
            titles?: Member.TitleInfo[];
            tier: number;
        };
        get frontend(): {
            hide: boolean;
            disable: boolean;
            reason: string;
        };
        name: string;
        description?: string;
        minLevel: number;
        maxLevel: number | null;
        minTier: number | null;
        maxTier: number | null;
        targetRestaurant?: Ref<Restaurant>[];
        options: BasicOption | ScheduleOption;
        requiredTitle?: Ref<MembershipTitle>;
        image?: string;
    }
    export {};
}
export declare namespace Task {
    class BaseOption implements I.Task.BaseOption {
        _id: Types.ObjectId;
        type: I.Task.Type;
        get id(): string;
    }
    class TotalSpentOption extends BaseOption implements I.Task.TotalSpentOption {
        type: I.Task.Type.totalSpent;
        require: number;
    }
    class TotalVisitOption extends BaseOption implements I.Task.TotalVisitOption {
        type: I.Task.Type.totalVisit;
        require: number;
        minSpent: number;
    }
    class TotalItemOption extends BaseOption implements I.Task.TotalItemOption {
        type: I.Task.Type.totalItem;
        require: number;
        itemsIds: string[];
    }
    type TaskOption = TotalSpentOption | TotalVisitOption | TotalItemOption;
    class Task {
        _id: Types.ObjectId;
        option: TaskOption;
        get id(): string;
    }
}
export declare namespace Level {
    class ExperienceRange implements I.Level.ExperienceRange {
        minLevel: number;
        expToLevelUp: number;
    }
    class CycleRule implements I.Level.CycleRule {
        minLevel: number;
        minExp: number;
        levelExpression: string | null;
        expExpression: string | null;
    }
    class Cycle implements I.Level.Cycle {
        resettedAt?: Date;
        month: number[];
        rules: CycleRule[];
    }
}
export declare namespace Reward {
    class RandomVoucherReward implements I.Reward.RandomVoucherReward {
        minLevel: number;
        voucher: Ref<Voucher>;
        weight: number;
    }
    class FixVoucherReward implements I.Reward.FixVoucherReward {
        level: number;
        voucher: Ref<Voucher>;
    }
    class OnLevelReward implements I.Reward.OnLevelReward {
        vouchers: RandomVoucherReward[];
        fixVouchers?: FixVoucherReward[];
        noRewardWeight: number;
    }
    class OnJoinReward implements I.Reward.OnJoinReward {
        vouchers: Ref<Voucher>[];
    }
}
export declare namespace Member {
    class ProductCount implements I.Member.ProductCount {
        id: string;
        count: number;
    }
    class MemberStat implements I.Member.Stat {
        visitCount: number;
        topupCount: number;
        lastVisit: Date | null;
        avgVisitFrequency: number;
        avgBillSize: number;
        products: ProductCount[];
    }
    class TitleInfo implements Member.TitleInfo {
        _id: Types.ObjectId;
        acquiredAt: Date;
        expiredAt: Date;
    }
    class Member implements I.Member.Member {
        _id: Types.ObjectId;
        business: Ref<Business>;
        membership: Ref<Membership>;
        user: string;
        cardNo?: string;
        level: number;
        experience: number;
        tier: number;
        stat: MemberStat;
        creditBalance: MemberCreditBalance;
        titles: TitleInfo[];
        get id(): any;
        get joinedAt(): Date;
        get balance(): number;
    }
}
export declare namespace Tier {
    class Tier implements I.Tier.Tier {
        minLevel: number;
        name: string;
    }
    class TierOption implements I.Tier.Option {
        baseTierName: string;
        tiers: Tier[];
    }
}
export declare namespace MembercardDesign {
    class Base implements I.MembercardDesign.Base {
        type: I.MembercardDesign.Type;
    }
    class Default extends MembercardDesign.Base implements I.MembercardDesign.Default {
        type: I.MembercardDesign.Type.default;
    }
    class Image extends MembercardDesign.Base implements I.MembercardDesign.Image {
        type: I.MembercardDesign.Type.image;
        image: string;
    }
}
export declare class CashbackSettings implements I.CashbackSettings {
    percentage: number;
    validFor: number;
}
export declare class Membership implements I.Membership {
    _id: Types.ObjectId;
    name: string;
    benefits: Benefit.Benefit[];
    onLevelReward: Reward.OnLevelReward;
    onJoinReward: Reward.OnJoinReward;
    baseExpToLevelUp: number;
    expRange: Level.ExperienceRange[];
    levelCycle?: Level.Cycle;
    tier: Tier.TierOption;
    titles: MembershipTitle[];
    store?: StoreOption;
    targetRestaurant: Ref<Restaurant>[];
    thumbnail?: string;
    design?: MembercardDesign.Default | MembercardDesign.Image;
    cashback?: I.CashbackSettings;
    creditOneToOne?: boolean;
    url?: string;
    get id(): any;
}
export declare class UpdateMembershipDto {
    name?: string;
    baseExpToLevelUp?: number;
    targetRestaurant?: Ref<Restaurant>[] | null;
    cashback?: CashbackSettings;
    creditOneToOne?: boolean;
    url?: string;
}
export declare class UpdateMemberTitleDto {
    id: string;
    expiredAt: Date;
}
export declare class UpdateMemberDto {
    titles?: UpdateMemberTitleDto[];
    level?: number;
    experience?: number;
    cardNo?: string;
}
export declare class LevelUp implements I.LevelUp {
    level: number;
    voucher: Types.ObjectId | null;
    fixVouchers?: Types.ObjectId[] | null;
}