/**
 *  @module Resources/Subscriptions
 */
import { AuthParams, PollData, PollParams, RestAPI, SendData } from "../api/RestAPI.js";
import { ProcessingMode } from "./common/enums.js";
import { Metadata, WithStoreMerchantName } from "./common/types.js";
import { ChargeCreateParams, Charges, ChargeThreeDsMode } from "./Charges.js";
import { ChargesListParams, ResponseCharges } from "./Charges.js";
import { CRUDAOSItemsResponse, CRUDPaginationParams, CRUDResource } from "./CRUDResource.js";
import { ResponseCharge } from "./index.js";
import { PaymentType } from "./TransactionTokens.js";
export declare enum SubscriptionPeriod {
    DAILY = "daily",
    WEEKLY = "weekly",
    BIWEEKLY = "biweekly",
    MONTHLY = "monthly",
    BIMONTHLY = "bimonthly",
    QUARTERLY = "quarterly",
    SEMIANNUALLY = "semiannually",
    ANNUALLY = "annually"
}
export declare enum SubscriptionStatus {
    UNVERIFIED = "unverified",
    CURRENT = "current",
    SUSPENDED = "suspended",
    UNPAID = "unpaid",
    CANCELED = "canceled",
    UNCONFIRMED = "unconfirmed",
    COMPLETED = "completed",
    AUTHORIZED = "authorized"
}
export declare enum InstallmentPlan {
    REVOLVING = "revolving",
    FIXED_CYCLES = "fixed_cycles",
    FIXED_CYCLE_AMOUNT = "fixed_cycle_amount"
}
export interface InstallmentBaseParams {
    planType: InstallmentPlan;
}
export interface InstallmentRevolvingParams extends InstallmentBaseParams {
    planType: InstallmentPlan.REVOLVING;
}
export interface ScheduledPaymentItem {
    id: string;
    dueDate: string;
    zoneId: string;
    amount: number;
    amountFormatted: number;
    currency: string;
    isPaid: boolean;
    isLastPayment: boolean;
    createdOn: string;
    successfulPaymentDate?: string;
    terminateWithStatus?: SubscriptionStatus;
    retryDate?: string;
    retryInterval?: string;
}
export type SchedulePaymentListItem = ScheduledPaymentItem;
export type InstallmentPlanItem = {
    planType: InstallmentPlan.REVOLVING;
} | {
    planType: InstallmentPlan.FIXED_CYCLES;
    fixedCycles: number;
};
export type SubscriptionPlanItem = {
    planType: InstallmentPlan.FIXED_CYCLES;
    fixedCycles: number;
} | {
    planType: InstallmentPlan.FIXED_CYCLE_AMOUNT;
    fixedCycleAmount: number;
};
export type SubscriptionsListParams = CRUDPaginationParams & {
    search?: string;
    status?: SubscriptionStatus;
    statuses?: SubscriptionStatus[];
    mode?: ProcessingMode;
};
export type ScheduledPaymentsListParams = CRUDPaginationParams;
export type SubscriptionCreateBaseParams<T extends Metadata = Metadata> = {
    transactionTokenId: string;
    amount: number;
    currency: string;
    descriptor?: string;
    initialAmount?: number;
    installmentPlan?: InstallmentPlanItem;
    subscriptionPlan?: SubscriptionPlanItem;
    onlyDirectCurrency?: boolean;
    threeDs?: {
        mode?: ChargeThreeDsMode;
        redirectEndpoint?: string;
        redirectId?: string;
    };
    /**
     * Metadata or stringified JSON object
     */
    metadata?: T | string;
    /**
     * Interval (e.g: P7D)
     *
     * Needs firstChargeAuthorizationOnly to be true to be used
     */
    firstChargeCaptureAfter?: string;
    firstChargeAuthorizationOnly?: boolean;
} & PeriodParams;
export type SubscriptionCreateLegacyParams = SubscriptionCreateBaseParams & {
    /**
     * @deprecated Used scheduleSettings instead
     */
    subsequentCyclesStart?: string | number;
};
export type SubscriptionCreateNewParams = SubscriptionCreateBaseParams & {
    scheduleSettings: Partial<ScheduleSettings>;
};
export type SubscriptionCreateParams = SubscriptionCreateLegacyParams | SubscriptionCreateNewParams;
export type SubscriptionUpdateParams<T extends Metadata = Metadata> = {
    transactionTokenId?: string;
    amount?: number;
    status?: SubscriptionStatus;
    installmentPlan?: Partial<InstallmentPlanItem>;
    subscriptionPlan?: Partial<SubscriptionPlanItem>;
    onlyDirectCurrency?: boolean;
    /**
     * Metadata or stringified JSON object
     */
    metadata?: T | string;
    /**
     * Interval (e.g: P7D)
     *
     * Needs firstChargeAuthorizationOnly to be true to be used
     */
    firstChargeCaptureAfter?: string;
    firstChargeAuthorizationOnly?: boolean;
    scheduleSettings?: {
        terminationMode?: TerminateMode;
    };
};
export type PaymentUpdateParams = Partial<ScheduledPaymentItem>;
export declare enum TerminateMode {
    IMMEDIATE = "immediate",
    ON_NEXT_PAYMENT = "on_next_payment"
}
export type ScheduleSettings = {
    startOn?: string;
    zoneId: string;
    preserveEndOfMonth?: boolean;
    retryInterval?: string;
    terminationMode?: TerminateMode;
};
type PeriodParams = {
    /**
     * Can not be used with the cyclicalPeriod parameter
     */
    period: SubscriptionPeriod;
} | {
    /**
     * ISO 8601 period. e.g P1M, P23D. Can not be used with the `period` parameter
     */
    cyclicalPeriod: string | null;
    period?: never;
};
export type SubscriptionItem<T extends Metadata = Metadata> = {
    id: string;
    storeId: string;
    transactionTokenId: string;
    mode: ProcessingMode;
    status: SubscriptionStatus;
    amount: number;
    amountFormatted: number;
    amountLeft: number;
    amountLeftFormatted: number;
    currency: string;
    paymentsLeft: number;
    descriptor: string;
    onlyDirectCurrency: boolean;
    createdOn: string;
    scheduleSettings: ScheduleSettings | null;
    nextPayment: ScheduledPaymentItem;
    threeDs?: {
        mode?: ChargeThreeDsMode;
        redirectEndpoint?: string;
        redirectId?: string;
    };
    nextPaymentDate?: string;
    initialAmount?: number | null;
    initialAmountFormatted?: number;
    subsequentCyclesStart?: string;
    installmentPlan?: InstallmentPlanItem;
    subscriptionPlan?: SubscriptionPlanItem;
    period?: SubscriptionPeriod;
    cyclicalPeriod?: string | null;
    cyclesLeft?: number;
    metadata?: T;
};
export type SubscriptionListItem<T extends Metadata = Metadata> = WithStoreMerchantName<SubscriptionItem<T>>;
type SubscriptionSimulationBaseParams = {
    installmentPlan?: InstallmentPlanItem | null;
    amount: number;
    currency: string;
    initialAmount?: number;
    paymentType: PaymentType;
} & PeriodParams;
export type SimulationInstallmentPayment = {
    amount: number;
    currency: string;
    dueDate: string;
    isLastPayment: boolean;
    isPaid: boolean;
    zoneId: string;
};
export type SubscriptionSimulationLegacyParams = SubscriptionSimulationBaseParams & {
    subsequentCyclesStart?: string | number;
};
export type SubscriptionSimulationNewParams = SubscriptionSimulationBaseParams & {
    scheduleSettings: ScheduleSettings;
};
export type SubscriptionSimulationParams = SubscriptionSimulationLegacyParams | SubscriptionSimulationNewParams;
export type CycleAmount = {
    cycleDate: string;
    amount: number;
};
export type SubscriptionSimulationLegacyItem = Required<SubscriptionSimulationLegacyParams> & {
    cycles: CycleAmount[];
};
export type SubscriptionSimulationNewItem = {
    [index: string]: Omit<ScheduledPaymentItem, "id" | "createdOn">;
};
export type SubscriptionSimulationItem = SubscriptionSimulationLegacyItem | SubscriptionSimulationNewItem;
export type ResponseSubscription<T extends Metadata = Metadata> = SubscriptionItem<T>;
export type ResponseSubscriptions<T extends Metadata = Metadata> = CRUDAOSItemsResponse<SubscriptionListItem<T>>;
export type ResponsePayment = ScheduledPaymentItem;
export type ResponsePayments = CRUDAOSItemsResponse<SchedulePaymentListItem>;
export type BatchSubscriptionCreateParams<T extends Metadata = Metadata> = {
    subscriptions: SubscriptionCreateParams[];
    charges?: ChargeCreateParams[];
    /**
     * Metadata or stringified JSON object
     */
    initialChargeMetadata?: T | string;
};
export declare enum BatchStatus {
    SUCCESSFUL = "successful",
    FAILED = "failed",
    AWAITING = "awaiting"
}
export type BatchSubscriptionResponse = {
    batchId: string;
    status: BatchStatus;
    subscriptionIds?: string[];
    chargeId?: string;
};
export declare class ScheduledPayments extends CRUDResource {
    static routeBase: string;
    private _list?;
    list(storeId: string, subscriptionsId: string, data?: SendData<ScheduledPaymentsListParams>, auth?: AuthParams): Promise<ResponsePayments>;
    private _get?;
    get(storeId: string, subscriptionsId: string, id: string, data?: SendData<void> | null, auth?: AuthParams): Promise<ResponsePayment>;
    private _update?;
    update(storeId: string, subscriptionsId: string, id: string, data?: SendData<PaymentUpdateParams>, auth?: AuthParams): Promise<ResponsePayment>;
    private _listCharges?;
    listCharges<T extends Metadata = Metadata>(storeId: string, subscriptionsId: string, paymentId: string, data?: SendData<ChargesListParams>, auth?: AuthParams): Promise<ResponseCharges<T>>;
}
export declare class Subscriptions extends CRUDResource {
    static requiredParams: (string | string[])[];
    static requiredSimulationParams: (string | string[])[];
    static routeBase: string;
    payments: ScheduledPayments;
    protected chargesResource: Charges;
    constructor(api: RestAPI);
    private _list;
    list<T extends Metadata = Metadata>(data?: SendData<SubscriptionsListParams>, auth?: AuthParams, storeId?: string): Promise<ResponseSubscriptions<T>>;
    private _suspend?;
    suspend<T extends Metadata = Metadata>(storeId: string, id: string, data?: SendData<{
        scheduleSettings?: {
            terminationMode?: TerminateMode;
        };
    }> | null, auth?: AuthParams | null): Promise<ResponseSubscription<T>>;
    private _unsuspend?;
    unsuspend<T extends Metadata = Metadata>(storeId: string, id: string, data?: SendData<{
        scheduleSettings?: {
            terminationMode?: TerminateMode;
        };
    }> | null, auth?: AuthParams | null): Promise<ResponseSubscription<T>>;
    private _updateToken?;
    updateToken<T extends Metadata = Metadata>(storeId: string, id: string, data?: SendData<{
        transactionTokenId: string;
    }>, auth?: AuthParams): Promise<ResponseSubscription<T>>;
    create<T extends Metadata = Metadata>(data: SubscriptionCreateParams, auth?: AuthParams): Promise<ResponseSubscription<T>>;
    createBatch(data: BatchSubscriptionCreateParams, auth?: AuthParams): Promise<BatchSubscriptionResponse>;
    private _get;
    get<T extends Metadata = Metadata>(storeId: string | null, id: string | null, data?: SendData<PollData> | null, auth?: AuthParams): Promise<ResponseSubscription<T>>;
    private _getBatch;
    getBatch(batchId: string, data?: SendData<PollData>, auth?: AuthParams): Promise<BatchSubscriptionResponse>;
    private _update;
    update<T extends Metadata = Metadata>(storeId: string | null, id: string | null, data?: SendData<SubscriptionUpdateParams> | null, auth?: AuthParams): Promise<ResponseSubscription<T>>;
    private _delete;
    delete(storeId: string | null, id: string | null, data?: SendData<void> | null, auth?: AuthParams): Promise<void>;
    private _charges;
    charges<T extends Metadata = Metadata>(storeId: string | null, id: string | null, data?: SendData<ChargesListParams> | null, auth?: AuthParams): Promise<ResponseCharges<T>>;
    poll<T extends Metadata = Metadata>(storeId: string, id: string, data?: SendData<PollData>, auth?: AuthParams, pollParams?: Partial<PollParams<ResponseSubscription<T>>>): Promise<ResponseSubscription<T>>;
    pollBatch(batchId: string, data?: SendData<PollData>, auth?: AuthParams, pollParams?: Partial<PollParams<BatchSubscriptionResponse>>): Promise<BatchSubscriptionResponse>;
    pollSubscriptionWithFirstCharge<T extends Metadata = Metadata, T2 extends Metadata = Metadata>(storeId: string, id: string, data?: SendData<PollData>, auth?: AuthParams): Promise<{
        subscription: ResponseSubscription<T>;
        charge: ResponseCharge<T2> | null;
    }>;
    private _simulation;
    simulation(data: SendData<SubscriptionSimulationParams>, auth?: AuthParams, storeId?: string): Promise<SimulationInstallmentPayment[]>;
}
export {};