import type { CartActionError } from './errors';
import type { Dispatch } from 'react';

export type ShoppingCartReducerDispatch = ( action: ShoppingCartAction ) => void;

export type ShoppingCartReducer = (
	state: ShoppingCartState,
	action: ShoppingCartAction
) => ShoppingCartState;

export type CartKey = number | 'no-user' | 'no-site';

export type GetCart = ( cartKey: CartKey ) => Promise< ResponseCart >;
export type SetCart = ( cartKey: CartKey, requestCart: RequestCart ) => Promise< ResponseCart >;

export interface ShoppingCartManagerOptions {
	refetchOnWindowFocus?: boolean;
	defaultCartKey?: CartKey;
}

export type GetManagerForKey = ( cartKey: CartKey | undefined ) => ShoppingCartManager;
export type GetCartKeyForSiteSlug = ( siteSlug: string ) => Promise< CartKey >;

export interface ShoppingCartManagerClient {
	forCartKey: GetManagerForKey;
	getCartKeyForSiteSlug: GetCartKeyForSiteSlug;
}

export type UnsubscribeFunction = () => void;

export type SubscribeCallback = () => void;

export type ShoppingCartManagerSubscribe = ( callback: SubscribeCallback ) => UnsubscribeFunction;

export interface SubscriptionManager {
	subscribe: ShoppingCartManagerSubscribe;
	notifySubscribers: () => void;
}

export interface ShoppingCartManagerState {
	isLoading: boolean;
	loadingError: string | null | undefined;
	loadingErrorType: ShoppingCartError | undefined;
	isPendingUpdate: boolean;
	responseCart: ResponseCart;
	couponStatus: CouponStatus;
}

type WaitForReady = () => Promise< ResponseCart >;

export type ShoppingCartManagerGetState = () => ShoppingCartManagerState;

export interface ShoppingCartManager {
	getState: ShoppingCartManagerGetState;
	subscribe: ShoppingCartManagerSubscribe;
	actions: ShoppingCartManagerActions;
	fetchInitialCart: WaitForReady;
}

export type UseShoppingCart = ShoppingCartManagerActions & ShoppingCartManagerState;

export type ReplaceProductInCart = (
	uuidToReplace: string,
	productPropertiesToChange: Partial< RequestCartProduct >
) => Promise< ResponseCart >;

export type ReloadCartFromServer = () => Promise< ResponseCart >;

export type ClearCartMessages = () => Promise< ResponseCart >;

export type ReplaceProductsInCart = (
	products: MinimalRequestCartProduct[]
) => Promise< ResponseCart >;

export type AddProductsToCart = (
	products: MinimalRequestCartProduct[]
) => Promise< ResponseCart >;

export type RemoveCouponFromCart = () => Promise< ResponseCart >;

export type ApplyCouponToCart = ( couponId: string ) => Promise< ResponseCart >;

export type RemoveProductFromCart = ( uuidToRemove: string ) => Promise< ResponseCart >;

export type UpdateTaxLocationInCart = ( location: CartLocation ) => Promise< ResponseCart >;

export type SetCouponFieldVisible = ( couponFieldVisible: boolean ) => void;

export type RemoveCouponAndClearField = () => Promise< ResponseCart< ResponseCartProduct > >;

/**
 * The custom hook keeps a cached version of the server cart, as well as a
 * cache status.
 *
 *   - 'fresh': Page has loaded and no requests have been sent.
 *   - 'fresh-pending': Page has loaded and we are waiting for the initial request.
 *   - 'invalid': Local cart data has been edited.
 *   - 'valid': Local cart has been reloaded from the server.
 *   - 'pending': Request has been sent, awaiting response.
 *   - 'error': Something went wrong.
 */
export type CacheStatus = 'fresh' | 'fresh-pending' | 'valid' | 'invalid' | 'pending' | 'error';

/**
 * Possible states re. coupon submission.
 *
 *   - 'fresh': User has not (yet) attempted to apply a coupon.
 *   - 'pending': Coupon request has been sent, awaiting response.
 *   - 'applied': Coupon has been applied to the cart.
 *   - 'rejected': Coupon code did not apply. The reason should be in the cart errors.
 */
export type CouponStatus = 'fresh' | 'pending' | 'applied' | 'rejected';

export type ShoppingCartAction =
	| { type: 'CLEAR_QUEUED_ACTIONS' }
	| { type: 'CLEAR_MESSAGES' }
	| { type: 'UPDATE_LAST_VALID_CART' }
	| { type: 'REMOVE_CART_ITEM'; uuidToRemove: string }
	| { type: 'CART_PRODUCTS_ADD'; products: RequestCartProduct[] }
	| { type: 'CART_PRODUCTS_REPLACE_ALL'; products: RequestCartProduct[] }
	| { type: 'SET_LOCATION'; location: CartLocation }
	| {
			type: 'CART_PRODUCT_REPLACE';
			uuidToReplace: string;
			productPropertiesToChange: Partial< RequestCartProduct >;
	  }
	| { type: 'ADD_COUPON'; couponToAdd: string }
	| { type: 'REMOVE_COUPON' }
	| { type: 'CART_RELOAD' }
	| { type: 'RECEIVE_INITIAL_RESPONSE_CART'; initialResponseCart: ResponseCart }
	| { type: 'FETCH_INITIAL_RESPONSE_CART' }
	| { type: 'REQUEST_UPDATED_RESPONSE_CART' }
	| { type: 'RECEIVE_UPDATED_RESPONSE_CART'; updatedResponseCart: ResponseCart }
	| { type: 'RAISE_ERROR'; error: ShoppingCartError; message: string };

export interface ShoppingCartManagerActions {
	addProductsToCart: AddProductsToCart;
	removeProductFromCart: RemoveProductFromCart;
	applyCoupon: ApplyCouponToCart;
	removeCoupon: RemoveCouponFromCart;
	updateLocation: UpdateTaxLocationInCart;
	replaceProductInCart: ReplaceProductInCart;
	replaceProductsInCart: ReplaceProductsInCart;
	reloadFromServer: ReloadCartFromServer;
	clearMessages: ClearCartMessages;
}

export type ShoppingCartError = 'GET_SERVER_CART_ERROR' | 'SET_SERVER_CART_ERROR';

export type ShoppingCartState = {
	responseCart: TempResponseCart;
	lastValidResponseCart: ResponseCart;
	couponStatus: CouponStatus;
	queuedActions: ShoppingCartAction[];
} & (
	| {
			cacheStatus: Exclude< CacheStatus, 'error' >;
			loadingError?: undefined;
			loadingErrorType?: undefined;
	  }
	| {
			cacheStatus: 'error';
			loadingError: string;
			loadingErrorType: ShoppingCartError;
	  }
);

export interface WithShoppingCartProps {
	shoppingCartManager: UseShoppingCart;
	cart: ResponseCart;
}

export type CartValidCallback = ( cart: ResponseCart ) => void;

export type DispatchAndWaitForValid = ( action: ShoppingCartAction ) => Promise< ResponseCart >;

export type SavedActionPromise = {
	resolve: ( responseCart: ResponseCart ) => void;
	reject: ( error: CartActionError ) => void;
};

export interface ActionPromises {
	resolve: ( tempResponseCart: TempResponseCart ) => void;
	reject: ( error: CartActionError ) => void;
	add: ( actionPromise: SavedActionPromise ) => void;
}

export interface CartSyncManager {
	syncPendingCartToServer: (
		state: ShoppingCartState,
		dispatch: Dispatch< ShoppingCartAction >
	) => void;
	fetchInitialCartFromServer: ( dispatch: Dispatch< ShoppingCartAction > ) => void;
}

export interface RequestCart {
	blog_id: number;
	cart_key?: CartKey;
	products: RequestCartProduct[];
	tax: RequestCartTaxData;
	coupon: string;
	temporary: false;
}

export type RequestCartTaxData = null | {
	location: {
		country_code: string | undefined;
		postal_code: string | undefined;
		subdivision_code: string | undefined;
		vat_id?: string;
		organization?: string;
		address?: string;
		city?: string;
	};
};

export interface RequestCartProduct {
	product_slug: string;
	product_id?: number;
	meta: string;
	volume: number;
	quantity: number | null;
	extra: RequestCartProductExtra;
}

export type MinimalRequestCartProduct = Partial< RequestCartProduct > &
	Pick< RequestCartProduct, 'product_slug' >;

export interface ResponseCart< P = ResponseCartProduct > {
	blog_id: number;
	cart_key: CartKey;
	products: P[];

	/**
	 * The amount of tax collected.
	 * @deprecated This is a float and is unreliable. Use total_tax_integer.
	 */
	total_tax: string;

	/**
	 * The amount of tax collected in the currency's smallest unit.
	 */
	total_tax_integer: number;

	/**
	 * The amount of tax collected per product.
	 */
	total_tax_breakdown: TaxBreakdownItem[];

	/**
	 * The cart's total cost.
	 * @deprecated This is a float and is unreliable. Use total_cost_integer.
	 */
	total_cost: number;

	/**
	 * The cart's total cost in the currency's smallest unit.
	 */
	total_cost_integer: number;

	/**
	 * The difference between the cost before any coupon and the actual price
	 * for all products in the currency's smallest unit.
	 *
	 * Note that the difference may be caused by many factors, not just coupons.
	 * It's best not to rely on it.
	 */
	coupon_savings_total_integer: number;

	/**
	 * The subtotal with taxes included in the currency's smallest unit.
	 *
	 * This is the sum of each item's price with all discounts (including
	 * coupons), but without taxes. This does not include credits!
	 */
	sub_total_with_taxes_integer: number;

	/**
	 * The subtotal without taxes included in the currency's smallest unit.
	 *
	 * This is the sum of each item's price with all discounts (including
	 * coupons), but without taxes. This does not include credits!
	 */
	sub_total_integer: number;

	/**
	 * The number of credits available in the currency's smallest unit.
	 */
	credits_integer: number;

	/**
	 * Gift Details
	 */
	gift_details?: ResponseCartGiftDetails;

	/**
	 * True if the cart contains a purchase for a different user's site.
	 */
	is_gift_purchase?: boolean;

	currency: string;
	allowed_payment_methods: string[];
	coupon: string;
	is_coupon_applied: boolean;
	has_auto_renew_coupon_been_automatically_applied: boolean;
	locale: string;
	is_signup: boolean;
	messages?: ResponseCartMessages;
	cart_generated_at_timestamp: number;
	tax: ResponseCartTaxData;
	next_domain_is_free: boolean;
	next_domain_condition: '' | 'blog';
	bundled_domain?: string;
	terms_of_service?: TermsOfServiceRecord[];
	has_pending_payment?: boolean;
}

export interface ResponseCartTaxData {
	location: {
		country_code?: string;
		postal_code?: string;
		subdivision_code?: string;
		vat_id?: string;
		organization?: string;
		address?: string;
		city?: string;
	};
	display_taxes: boolean;
}

export interface TaxBreakdownItem {
	tax_collected: number;
	tax_collected_integer: number;
	label?: string;
	rate: number;
	rate_display: string;
}

/**
 * Local schema for response cart that can contain incomplete products. This
 * schema is only used inside the reducer and will only differ from a
 * ResponseCart if the cacheStatus is invalid.
 */
export type TempResponseCart = ResponseCart< RequestCartProduct >;

export interface ResponseCartMessages {
	errors?: ResponseCartMessage[];
	success?: ResponseCartMessage[];
	persistent_errors?: ResponseCartMessage[];
}

export interface ResponseCartMessage {
	code: string;
	message: string;
}

export interface ResponseCartProduct {
	uuid: string;
	product_name: string;
	product_slug: string;
	product_id: number;
	currency: string;

	product_name_en: string;

	/**
	 * The cart item's original price without volume in the currency's smallest unit.
	 *
	 * Discounts and volume are not included, but quantity is included.
	 */
	item_original_cost_integer: number;

	/**
	 * The monthly term original price of a cart item in the currency's smallest unit.
	 */
	item_original_monthly_cost_integer: number;

	/**
	 * The cart item's original price with volume in the currency's smallest unit.
	 *
	 * Discounts are not included, but volume and quantity are included.
	 */
	item_original_subtotal_integer: number;

	/**
	 * The cart item's original price for quantity 1 in the currency's smallest unit.
	 *
	 * Discounts are not included, but volume is included.
	 */
	item_original_cost_for_quantity_one_integer: number;

	/**
	 * The cart item's subtotal in the currency's smallest unit.
	 *
	 * This is the cost of the item with all discounts (including coupons),
	 * but without taxes.
	 */
	item_subtotal_integer: number;

	/**
	 * The cart item's subtotal without volume.
	 * @deprecated This is a float and is unreliable. Use item_subtotal_integer
	 */
	cost: number;

	/**
	 * The amount of the local currency deducted by an applied coupon, if any.
	 * This is in the currency's smallest unit.
	 */
	coupon_savings_integer?: number;

	price_tier_minimum_units?: number | null;
	price_tier_maximum_units?: number | null;

	/**
	 * A cost override is a change to the price of a product. The new price and the old (original) price are both provided.
	 *
	 * The override_code is a string that identifies the reason for the override.
	 * When displaying the reason to the customer, use the human_readable_reason.
	 */
	cost_overrides: ResponseCartCostOverride[];

	/**
	 * If set, is used to transform the usage/quantity of units used to derive the number of units
	 * we want to bill the customer for, before applying the per unit cost.
	 *
	 * To put simply, the purpose of this attribute is to bill the customer at a different granularity compared to their usage.
	 */
	price_tier_transform_quantity_divide_by?: number | null;

	/**
	 * Used for rounding the number of units we want to bill the customer for (which is derived after dividing the
	 * usage/quantity of units by the `price_tier_transform_quantity_divide_by` number).
	 *
	 * Used only when `$this->price_tier_transform_quantity_divide_by` is set. Possible values are: `up`, `down`
	 */
	price_tier_transform_quantity_round?: string | null;
	is_domain_registration: boolean;
	is_bundled: boolean;
	is_sale_coupon_applied: boolean;
	meta: string;
	time_added_to_cart: number;

	/**
	 * The billing term in days in numeric format, but as a string.
	 *
	 * Typically one of '31' (monthly), '365' (annual), or '730' (biennial).
	 *
	 * Similar to `months_per_bill_period`.
	 */
	bill_period: string;

	/**
	 * The billing term in months in numeric format.
	 *
	 * Typically one of 1 (monthly), 12 (annual), or 24 (biennial).
	 *
	 * Similar to `bill_period`.
	 */
	months_per_bill_period: number | null;

	volume: number;
	quantity: number | null;
	current_quantity: number | null;
	extra: ResponseCartProductExtra;
	item_tax: number;
	item_tax_rate?: number;
	product_type: string;
	included_domain_purchase_amount: number;

	/**
	 * True if the product is a renewal.
	 *
	 * This does not get set for `RequestCartProduct` which instead uses
	 * `extra.purchaseType` set to 'renewal'.
	 */
	is_renewal?: boolean;

	/**
	 * True if the product is a renewal and the subscription will auto-renew.
	 *
	 * A subscription will auto-renew if it both can auto-renew (it's a recurring subscription,
	 * has a payment method, isn't blocked, etc.) and the user has auto-renew enabled.
	 */
	is_renewal_and_will_auto_renew?: boolean;

	/**
	 * True if the product will not renew.
	 */
	is_one_time_purchase?: boolean;

	subscription_id?: string;
	introductory_offer_terms?: IntroductoryOfferTerms;

	/**
	 * True if the cart item represents a purchase for a different user's site.
	 */
	is_gift_purchase?: boolean;

	/**
	 * True if cart item is a domain that is included in a 100 Year Plan
	 */
	is_included_for_100yearplan: boolean;

	/**
	 * If set, this is the ID of the payment method attached to the existing
	 * subscription for this product. This will only be set for renewals and
	 * only if the renewal has a payment method attached.
	 */
	stored_details_id?: string;

	product_variants: ResponseCartProductVariant[];
}

export interface ResponseCartProductVariant {
	product_id: number;
	bill_period_in_months: number;
	product_slug: string;
	currency: string;
	price_integer: number;
	price_before_discounts_integer: number;
	introductory_offer_discount_integer: number;
	introductory_offer_terms:
		| Record< string, never >
		| Pick< IntroductoryOfferTerms, 'interval_unit' | 'interval_count' >;
	volume?: number;
}

export interface ResponseCartCostOverride {
	human_readable_reason: string;
	new_subtotal_integer: number;
	old_subtotal_integer: number;
	override_code: string;
	does_override_original_cost: boolean;
	percentage: number;
	first_unit_only: boolean;
}

export type IntroductoryOfferUnit = 'day' | 'week' | 'month' | 'year' | 'indefinite';

export interface IntroductoryOfferTerms {
	/**
	 * True if the introductory offer is active on this product.
	 */
	enabled: boolean;

	/**
	 * The unit that, when combined with `interval_count`, determines how long
	 * the introductory offer disount should be applied.
	 */
	interval_unit: IntroductoryOfferUnit;

	/**
	 * The count that, when combined with `interval_unit`, determines how long
	 * the introductory offer lasts. eg: if `interval_count` is 3 and
	 * `interval_unit` is 'month', the discount lasts for 3 months (but always
	 * ends before the next renewal unless `transition_after_renewal_count` is
	 * set). If the `interval_unit` is 'month' and the product normally renews
	 * yearly, then the first renewal will be based on `interval_count` (eg:
	 * after 3 months) instead.
	 *
	 * Note that we sometimes renew products a 30 days before their expiry
	 * date, so in the above example, we would likely renew at the 2 month mark
	 * instead.
	 */
	interval_count: number;

	/**
	 * If the introductory offer is not active (if `enabled` is false), the
	 * reason will probably be a human-readable reason why (although it may not
	 * exist even then).
	 */
	reason?: string;

	/**
	 * The number of times the introductory offer cost and period will be used
	 * during renewals before using the regular cost and period. If this is 0,
	 * the discount will last just for the initial purchase; otherwise it will
	 * last for additional renewals also.
	 */
	transition_after_renewal_count: number;

	/**
	 * True if the last discounted renewal will subtract the introductory offer
	 * period from the full period when calculating the price. For example: if
	 * you provide a 3 month free trial on a yearly plan, the first renewal
	 * would only cover 9 months (12 – 3 months). This reduced period is also
	 * reflected in the renewal price, as the user will only pay for the 9
	 * months instead of the full year.
	 */
	should_prorate_when_offer_ends: boolean;
}

export interface CartLocation {
	countryCode?: string;
	postalCode?: string;
	subdivisionCode?: string;
	vatId?: string;
	organization?: string;
	address?: string;
	city?: string;
}

export type DomainLegalAgreementUrl = string;
export type DomainLegalAgreementTitle = string;
export type DomainLegalAgreements = Record< DomainLegalAgreementUrl, DomainLegalAgreementTitle >;

export interface ResponseCartProductExtra {
	context?: string;
	source?: string;
	premium?: boolean;
	new_quantity?: number;
	domain_to_bundle?: string;
	email_users?: TitanProductUser[];
	google_apps_users?: GSuiteProductUser[];
	google_apps_registration_data?: DomainContactDetails;
	receipt_for_domain?: number;
	domain_registration_agreement_url?: string;
	legal_agreements?: never[] | DomainLegalAgreements;
	is_gravatar_domain?: boolean;

	/**
	 * Set to 'renewal' if requesting a renewal.
	 *
	 * Often this does not need to be explicitly set because the shopping cart
	 * endpoint will automatically make a requested product into a renewal if the
	 * product is already owned.
	 *
	 * This is not set for `ResponseCartProduct` objects which use `is_renewal`
	 * instead.
	 */
	purchaseType?: string;

	afterPurchaseUrl?: string;
	isJetpackCheckout?: boolean;
	isAkismetSitelessCheckout?: boolean;
	isMarketplaceSitelessCheckout?: boolean;

	/**
	 * Marketplace properties
	 *
	 * These extra properties are always set for marketplace products.
	 * `product_slug` is for identifying the product, and `product_type` is for identifying the type of the product.
	 */
	is_marketplace_product?: boolean;
	product_slug?: string;
	product_type?: 'marketplace_plugin' | 'marketplace_theme' | 'saas_plugin';

	/**
	 * True when:
	 * - the product has variants ( e.g. annual plan vs. monthly plan vs. multi-year plan )
	 * - we only want to show the single product selected by the user
	 * - we want to prevent the user from switching to a variant
	 *
	 * This will hide product variant UI elements in checkout ( line item variant dropdown or variant upsells )
	 */
	hideProductVariants?: boolean;
}

export interface ResponseCartGiftDetails {
	receiver_blog_id: number;
	receiver_blog_slug?: string;
	receiver_blog_url?: string;
}

export interface RequestCartProductExtra extends ResponseCartProductExtra {
	purchaseId?: string;
	isAkismetSitelessCheckout?: boolean;
	isJetpackCheckout?: boolean;
	isMarketplaceSitelessCheckout?: boolean;
	intentId?: number;
	isGiftPurchase?: boolean;
	jetpackSiteSlug?: string;
	jetpackPurchaseToken?: string;
	auth_code?: string;
	privacy_available?: boolean;
	selected_page_titles?: string[];
	site_title?: string;
	signup_flow?: string;
	import_dns_records?: boolean;
	signup?: boolean;
	headstart_theme?: string;
	feature_slug?: string;
	is_hundred_year_domain?: boolean;
	/**
	 * A way to signal intent to the back end when included as an extra with
	 * certain products.
	 *
	 * The only current usage is on Creator plan products that are bought
	 * on flow `/setup/site-migration`. If value `'migrate` is passed the
	 * Atomic DB will be created with UTF-8 encoding, which is a requirement
	 * for Migration Guru, our new tool for handling migrations. This extra
	 * can be removed once all migration flows are using Migration Guru.
	 *
	 */
	hosting_intent?: string;
}

export interface GSuiteProductUser {
	firstname: string;
	lastname: string;
	email: string;
	password: string;
	recoveryEmail?: string;
}

export interface TitanProductUser {
	alternative_email?: string;
	email: string;
	encrypted_password?: string;
	is_admin?: boolean;
	name?: string;
	password?: string;
}

export type DomainContactDetails = {
	firstName?: string;
	lastName?: string;
	organization?: string;
	email?: string;
	phone?: string;
	address1?: string;
	address2?: string;
	city?: string;
	state?: string;
	postalCode?: string;
	countryCode?: string;
	fax?: string;
	vatId?: string;
	extra?: DomainContactDetailsExtra;
};

export type DomainContactDetailsExtra = {
	ca?: CaDomainContactExtraDetails | null;
	uk?: UkDomainContactExtraDetails | null;
	fr?: FrDomainContactExtraDetails | null;
};

export type CaDomainContactExtraDetails = {
	lang?: string;
	legalType?: string;
	ciraAgreementAccepted?: boolean;
};

export type UkDomainContactExtraDetails = {
	registrantType?: string;
	registrationNumber?: string;
	tradingName?: string;
};

export type FrDomainContactExtraDetails = {
	registrantType?: string;
	registrantVatId?: string;
	trademarkNumber?: string;
	sirenSiret?: string;
};

export interface TermsOfServiceRecord {
	key: string;
	code: string;
	args?: TermsOfServiceRecordArgsBase | TermsOfServiceRecordArgsRenewal;
}

export interface TermsOfServiceRecordArgsBase {
	/**
	 * The date that the subscription will begin, formatted as a ISO 8601 date
	 * (eg: `2004-02-12T15:19:21+00:00`).
	 */
	subscription_start_date: string;

	/**
	 * The `meta` value of the product (eg: its domain name). May be an empty
	 * string if there is no meta.
	 */
	product_meta: string;

	/**
	 * The human readable name of the product.
	 */
	product_name: string;

	/**
	 * The store product ID.
	 */
	product_id: number;

	/**
	 * The price of the next renewal of this product. This may be based on the
	 * product's billing term (eg: in two years for a biennial plan) or the
	 * billing term of the introductory offer, if it differs (eg: in 3 months for
	 * a 3 month free trial of an annual plan).
	 *
	 * If an introductory offer applies for more than one renewal, this will be
	 * the price of the next renewal only, NOT the price of the renewal after the
	 * offer ends!
	 *
	 * This price is locale-formatted with a currency symbol.
	 * @deprecated use renewal_price_integer and format manually
	 */
	renewal_price: string;

	/**
	 * The price of the next renewal of this product. This may be based on the
	 * product's billing term (eg: in two years for a biennial plan) or the
	 * billing term of the introductory offer, if it differs (eg: in 3 months for
	 * a 3 month free trial of an annual plan).
	 *
	 * If an introductory offer applies for more than one renewal, this will be
	 * the price of the next renewal only, NOT the price of the renewal after the
	 * offer ends!
	 *
	 * This price is an integer in the currency's smallest unit.
	 */
	renewal_price_integer: number;

	/**
	 * The price of the product after the promotional pricing expires. If the
	 * next auto-renewal after the price expires would prorate the renewal price,
	 * this DOES NOT include that proration. See
	 * `maybe_prorated_regular_renewal_price_integer` for the price with that proration
	 * included.
	 *
	 * This price is locale-formatted with a currency symbol.
	 * @deprecated use regular_renewal_price_integer and format manually
	 */
	regular_renewal_price: string;

	/**
	 * The price of the product after the promotional pricing expires. If the
	 * next auto-renewal after the price expires would prorate the renewal price,
	 * this DOES NOT include that proration. See
	 * `maybe_prorated_regular_renewal_price_integer` for the price with that proration
	 * included.
	 *
	 * This price is an integer in the currency's smallest unit.
	 */
	regular_renewal_price_integer: number;

	/**
	 * The price of the product for the renewal immediately after the promotional
	 * pricing expires. If the next auto-renewal after the price expires would
	 * prorate the renewal price, this DOES include that proration. See
	 * `regular_renewal_price_integer` for the price without that proration
	 * included.
	 *
	 * This is the price that we will attempt to charge on
	 * `subscription_maybe_prorated_regular_auto_renew_date`.
	 *
	 * This price is an integer in the currency's smallest unit.
	 */
	maybe_prorated_regular_renewal_price_integer: number;

	/**
	 * True if the product in the cart which has these terms is a manual renewal
	 * (as opposed to a new purchase or a quantity upgrade).
	 */
	is_renewal: boolean;

	/**
	 * The number of auto-renewals after the current purchase completes which
	 * will be affected by the promotional pricing. If the product is affected by
	 * a prorated introductory offer, then the auto-renewal where the user will
	 * be charged the prorated price is not counted by this number.
	 */
	remaining_promotional_auto_renewals: number;
}

export interface TermsOfServiceRecordArgsRenewal extends TermsOfServiceRecordArgsBase {
	/**
	 * The date that the promotional pricing will end, formatted as a ISO 8601
	 * date (eg: `2004-02-12T15:19:21+00:00`). This may be the date that an
	 * auto-renew will be attempted with the non-promotional price, but if the
	 * subscription renews earlier than the expiry date, the renewal may happen
	 * earlier than this date. See `subscription_regular_auto_renew_date` for
	 * the actual date of the non-promotional renewal.
	 *
	 * Only set if we can easily determine when the product will renew. Does not
	 * apply to domain transfers or multi-year domains.
	 */
	subscription_end_of_promotion_date: string;

	/**
	 * This date that an auto-renew will be attempted with the non-promotional
	 * possibly prorated price (`maybe_prorated_regular_renewal_price_integer`).
	 *
	 * This is ISO 8601 formatted (eg: `2004-02-12T15:19:21+00:00`).
	 *
	 * Only set if we can easily determine when the product will renew. Does not
	 * apply to domain transfers or multi-year domains.
	 */
	subscription_maybe_prorated_regular_auto_renew_date: string;

	/**
	 * This date that an auto-renew will be attempted with the non-promotional
	 * regular recurring price (`regular_renewal_price_integer`).
	 *
	 * This is ISO 8601 formatted (eg: `2004-02-12T15:19:21+00:00`).
	 *
	 * Only set if we can easily determine when the product will renew. Does not
	 * apply to domain transfers or multi-year domains.
	 */
	subscription_regular_auto_renew_date: string;

	/**
	 * The date when the product's subscription will expire if not renewed. This
	 * might be its renewal date, but it might not be since we often renew
	 * products earlier than their expiry date.
	 *
	 * This is ISO 8601 formatted (eg: `2004-02-12T15:19:21+00:00`).
	 *
	 * Only set if we can easily determine when the product will renew. Does not
	 * apply to domain transfers or multi-year domains.
	 */
	subscription_expiry_date: string;

	/**
	 * The date when the product's subscription will next automatically attempt a
	 * renewal. Note that this may not be the end of the promotional price, since
	 * some promotions apply to renewals also.
	 *
	 * This is ISO 8601 formatted (eg: `2004-02-12T15:19:21+00:00`).
	 *
	 * Only set if we can easily determine when the product will renew. Does not
	 * apply to domain transfers or multi-year domains.
	 */
	subscription_auto_renew_date: string;

	/**
	 * The number of days before the renewal attempt when the user will receive a
	 * pre-renewal reminder email.
	 *
	 * Only set if we can easily determine when the product will renew. Does not
	 * apply to domain transfers or multi-year domains.
	 */
	subscription_pre_renew_reminder_days: number;

	/**
	 * The number of pre-renewal emails the user will receive.
	 *
	 * Typically this is 1 or 0. For example, monthly subscriptions don't usually
	 * get a pre-renewal email.
	 *
	 * Only set if we can easily determine when the product will renew. Does not
	 * apply to domain transfers or multi-year domains.
	 */
	subscription_pre_renew_reminders_count: number;
}