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

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 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 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 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 VendureEvent {
  constructor(ctx: RequestContext, order: Order, type: 'created' | 'updated' | 'deleted')
}

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

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 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 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 StockMovementEvent extends VendureEvent {
  public readonly public readonly type: StockMovementType;
  constructor(ctx: RequestContext, stockMovements: StockMovement[])
}

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[])
}