Event Types

class AccountVerifiedEvent extends VendureEvent {    constructor(ctx: RequestContext, customer: Customer)}

class AdministratorEvent extends VendureEntityEvent<Administrator, AdministratorInputTypes> {    constructor(ctx: RequestContext, entity: Administrator, type: 'created' | 'updated' | 'deleted', input?: AdministratorInputTypes)}

class AdministratorPasswordResetEvent extends VendureEvent {    constructor(ctx: RequestContext, administrator: Administrator, user: User)}

class ApiKeyEvent extends VendureEntityEvent<ApiKey, ApiKeyInputTypes> {    constructor(ctx: RequestContext, entity: ApiKey, type: 'created' | 'updated' | 'deleted', input?: ApiKeyInputTypes)}

class AssetChannelEvent extends VendureEvent {    constructor(ctx: RequestContext, asset: Asset, channelId: ID, type: 'assigned' | 'removed')}

class AssetEvent extends VendureEntityEvent<Asset, AssetInputTypes> {    constructor(ctx: RequestContext, entity: Asset, type: 'created' | 'updated' | 'deleted', input?: AssetInputTypes)    asset: Asset}

class AttemptedLoginEvent extends VendureEvent {    constructor(ctx: RequestContext, strategy: string, identifier?: string)}

class BootstrappedEvent extends VendureEvent {    constructor()}

class ChangeChannelEvent<T extends ChannelAware & VendureEntity> extends VendureEvent {    constructor(ctx: RequestContext, entity: T, channelIds: ID[], type: 'assigned' | 'removed', entityType?: Type<T>)}

class ChannelEvent extends VendureEntityEvent<Channel, ChannelInputTypes> {    constructor(ctx: RequestContext, entity: Channel, type: 'created' | 'updated' | 'deleted', input?: ChannelInputTypes)}

class CollectionEvent extends VendureEntityEvent<Collection, CollectionInputTypes> {    constructor(ctx: RequestContext, entity: Collection, type: 'created' | 'updated' | 'deleted', input?: CollectionInputTypes)}

class CollectionModificationEvent extends VendureEvent {    constructor(ctx: RequestContext, collection: Collection, productVariantIds: ID[])}

class CountryEvent extends VendureEntityEvent<Country, CountryInputTypes> {    constructor(ctx: RequestContext, entity: Country, type: 'created' | 'updated' | 'deleted', input?: CountryInputTypes)}

class CouponCodeEvent extends VendureEvent {    constructor(ctx: RequestContext, couponCode: string, orderId: ID, type: 'assigned' | 'removed')}

class CustomerAddressEvent extends VendureEntityEvent<Address, CustomerAddressInputTypes> {    constructor(ctx: RequestContext, entity: Address, type: 'created' | 'updated' | 'deleted', input?: CustomerAddressInputTypes)    address: Address}

class CustomerEvent extends VendureEntityEvent<Customer, CustomerInputTypes> {    constructor(ctx: RequestContext, entity: Customer, type: 'created' | 'updated' | 'deleted', input?: CustomerInputTypes)    customer: Customer}

class CustomerGroupChangeEvent extends VendureEvent {    constructor(ctx: RequestContext, customers: Customer[], customGroup: CustomerGroup, type: 'assigned' | 'removed')}

class CustomerGroupEvent extends VendureEntityEvent<CustomerGroup, CustomerGroupInputTypes> {    constructor(ctx: RequestContext, entity: CustomerGroup, type: 'created' | 'updated' | 'deleted', input?: CustomerGroupInputTypes)}

class FacetEvent extends VendureEntityEvent<Facet, FacetInputTypes> {    constructor(ctx: RequestContext, entity: Facet, type: 'created' | 'updated' | 'deleted', input?: FacetInputTypes)}

class FacetValueEvent extends VendureEntityEvent<FacetValue, FacetValueInputTypes> {    constructor(ctx: RequestContext, entity: FacetValue, type: 'created' | 'updated' | 'deleted', input?: FacetValueInputTypes)}

class FulfillmentEvent extends VendureEntityEvent<Fulfillment, CreateFulfillmentInput> {    constructor(ctx: RequestContext, entity: Fulfillment, input?: CreateFulfillmentInput)}

class FulfillmentStateTransitionEvent extends VendureEvent {    constructor(fromState: FulfillmentState, toState: FulfillmentState, ctx: RequestContext, fulfillment: Fulfillment)}

class GlobalSettingsEvent extends VendureEntityEvent<GlobalSettings, UpdateGlobalSettingsInput> {    constructor(ctx: RequestContext, entity: GlobalSettings, input?: UpdateGlobalSettingsInput)}

class HistoryEntryEvent extends VendureEntityEvent<HistoryEntry, HistoryInput> {    public readonly historyType: 'order' | 'customer' | string;    constructor(ctx: RequestContext, entity: HistoryEntry, type: 'created' | 'updated' | 'deleted', historyType: 'order' | 'customer' | string, input?: HistoryInput)}

class IdentifierChangeEvent extends VendureEvent {    constructor(ctx: RequestContext, user: User, oldIdentifier: string)}

class IdentifierChangeRequestEvent extends VendureEvent {    constructor(ctx: RequestContext, user: User)}

class InitializerEvent extends VendureEvent {    constructor()}

class LoginEvent extends VendureEvent {    constructor(ctx: RequestContext, user: User)}

class LogoutEvent extends VendureEvent {    constructor(ctx: RequestContext)}

class OrderEvent extends VendureEntityEvent<Order, OrderInputTypes> {    constructor(ctx: RequestContext, order: Order, type: 'created' | 'updated' | 'deleted', input?: OrderInputTypes)    order: Order}

class OrderLineEvent extends VendureEvent {    constructor(ctx: RequestContext, order: Order, orderLine: OrderLine, type: 'created' | 'updated' | 'deleted' | 'cancelled')}

class OrderPlacedEvent extends VendureEvent {    constructor(fromState: OrderState, toState: OrderState, ctx: RequestContext, order: Order)}

class OrderStateTransitionEvent extends VendureEvent {    constructor(fromState: OrderState, toState: OrderState, ctx: RequestContext, order: Order)}

class PasswordResetEvent extends VendureEvent {    constructor(ctx: RequestContext, user: User)}

class PasswordResetVerifiedEvent extends VendureEvent {    constructor(ctx: RequestContext, user: User)}

class PaymentMethodEvent extends VendureEntityEvent<PaymentMethod, PaymentMethodInputTypes> {    constructor(ctx: RequestContext, entity: PaymentMethod, type: 'created' | 'updated' | 'deleted', input?: PaymentMethodInputTypes)}

class PaymentStateTransitionEvent extends VendureEvent {    constructor(fromState: PaymentState, toState: PaymentState, ctx: RequestContext, payment: Payment, order: Order)}

class ProductChannelEvent extends VendureEvent {    constructor(ctx: RequestContext, product: Product, channelId: ID, type: 'assigned' | 'removed')}

class ProductEvent extends VendureEntityEvent<Product, ProductInputTypes> {    constructor(ctx: RequestContext, entity: Product, type: 'created' | 'updated' | 'deleted', input?: ProductInputTypes)    product: Product}

class ProductOptionEvent extends VendureEntityEvent<ProductOption, ProductOptionInputTypes> {    constructor(ctx: RequestContext, entity: ProductOption, type: 'created' | 'updated' | 'deleted', input?: ProductOptionInputTypes)}

class ProductOptionGroupChangeEvent extends VendureEvent {    constructor(ctx: RequestContext, product: Product, optionGroupId: ID, type: 'assigned' | 'removed')}

class ProductOptionGroupEvent extends VendureEntityEvent<    ProductOptionGroup,    ProductOptionGroupInputTypes> {    constructor(ctx: RequestContext, entity: ProductOptionGroup, type: 'created' | 'updated' | 'deleted', input?: ProductOptionGroupInputTypes)}

class ProductVariantChannelEvent extends VendureEvent {    constructor(ctx: RequestContext, productVariant: ProductVariant, channelId: ID, type: 'assigned' | 'removed')}

class ProductVariantEvent extends VendureEntityEvent<ProductVariant[], ProductVariantInputTypes> {    constructor(ctx: RequestContext, entity: ProductVariant[], type: 'created' | 'updated' | 'deleted', input?: ProductVariantInputTypes)    variants: ProductVariant[]}

class ProductVariantPriceEvent extends VendureEntityEvent<    ProductVariantPrice[],    ProductVariantInputTypes> {    constructor(ctx: RequestContext, entity: ProductVariantPrice[], type: 'created' | 'updated' | 'deleted', input?: ProductVariantInputTypes)}

class PromotionEvent extends VendureEntityEvent<Promotion, PromotionInputTypes> {    constructor(ctx: RequestContext, entity: Promotion, type: 'created' | 'updated' | 'deleted', input?: PromotionInputTypes)}

class ProvinceEvent extends VendureEntityEvent<Province, ProvinceInputTypes> {    constructor(ctx: RequestContext, entity: Province, type: 'created' | 'updated' | 'deleted', input?: ProvinceInputTypes)}

class RefundEvent extends VendureEvent {    constructor(ctx: RequestContext, order: Order, refund: Refund, type: 'created')}

class RefundStateTransitionEvent extends VendureEvent {    constructor(fromState: RefundState, toState: RefundState, ctx: RequestContext, refund: Refund, order: Order)}

class RoleChangeEvent extends VendureEvent {    constructor(ctx: RequestContext, admin: Administrator, roleIds: ID[], type: 'assigned' | 'removed')}

class RoleEvent extends VendureEntityEvent<Role, RoleInputTypes> {    constructor(ctx: RequestContext, entity: Role, type: 'created' | 'updated' | 'deleted', input?: RoleInputTypes)}

class SearchEvent extends VendureEvent {    constructor(ctx: RequestContext, input: ExtendedSearchInput)}

class SellerEvent extends VendureEntityEvent<Seller, SellerInputTypes> {    constructor(ctx: RequestContext, entity: Seller, type: 'created' | 'updated' | 'deleted', input?: SellerInputTypes)}

class ShippingMethodEvent extends VendureEntityEvent<ShippingMethod, ShippingMethodInputTypes> {    constructor(ctx: RequestContext, entity: ShippingMethod, type: 'created' | 'updated' | 'deleted', input?: ShippingMethodInputTypes)}

class StockLocationEvent extends VendureEntityEvent<StockLocation, StockLocationInputTypes> {    constructor(ctx: RequestContext, entity: StockLocation, type: 'created' | 'updated' | 'deleted', input?: StockLocationInputTypes)}

class StockMovementEvent extends VendureEvent {    public readonly type: StockMovementType;    constructor(ctx: RequestContext, stockMovements: StockMovement[])}

interface StockShortfall {    productVariantId: ID;    orderLineId: ID;    requested: number;    allocated: number;}

class StockShortfallEvent extends VendureEvent {    constructor(ctx: RequestContext, order: Order, shortfalls: StockShortfall[])}

class TaxCategoryEvent extends VendureEntityEvent<TaxCategory, TaxCategoryInputTypes> {    constructor(ctx: RequestContext, entity: TaxCategory, type: 'created' | 'updated' | 'deleted', input?: TaxCategoryInputTypes)}

class TaxRateEvent extends VendureEntityEvent<TaxRate, TaxRateInputTypes> {    constructor(ctx: RequestContext, entity: TaxRate, type: 'created' | 'updated' | 'deleted', input?: TaxRateInputTypes)}

class TaxRateModificationEvent extends VendureEvent {    constructor(ctx: RequestContext, taxRate: TaxRate)}

class ZoneEvent extends VendureEntityEvent<Zone, ZoneInputTypes> {    constructor(ctx: RequestContext, entity: Zone, type: 'created' | 'updated' | 'deleted', input?: ZoneInputTypes)}

class ZoneMembersEvent extends VendureEvent {    constructor(ctx: RequestContext, entity: Zone, type: 'assigned' | 'removed', memberIds: ID[])}