/* PayfuncComponent custom elements bundle */

import type { Components, JSX } from "../types/components";

interface CardLogotypes extends Components.CardLogotypes, HTMLElement {}
export const CardLogotypes: {
  prototype: CardLogotypes;
  new (): CardLogotypes;
};

interface ComponentDemo extends Components.ComponentDemo, HTMLElement {}
export const ComponentDemo: {
  prototype: ComponentDemo;
  new (): ComponentDemo;
};

interface CustomerAddress extends Components.CustomerAddress, HTMLElement {}
export const CustomerAddress: {
  prototype: CustomerAddress;
  new (): CustomerAddress;
};

interface CustomerBalance extends Components.CustomerBalance, HTMLElement {}
export const CustomerBalance: {
  prototype: CustomerBalance;
  new (): CustomerBalance;
};

interface CustomerError extends Components.CustomerError, HTMLElement {}
export const CustomerError: {
  prototype: CustomerError;
  new (): CustomerError;
};

interface CustomerLogin extends Components.CustomerLogin, HTMLElement {}
export const CustomerLogin: {
  prototype: CustomerLogin;
  new (): CustomerLogin;
};

interface CustomerMethods extends Components.CustomerMethods, HTMLElement {}
export const CustomerMethods: {
  prototype: CustomerMethods;
  new (): CustomerMethods;
};

interface CustomerOrders extends Components.CustomerOrders, HTMLElement {}
export const CustomerOrders: {
  prototype: CustomerOrders;
  new (): CustomerOrders;
};

interface CustomerSubscriptions extends Components.CustomerSubscriptions, HTMLElement {}
export const CustomerSubscriptions: {
  prototype: CustomerSubscriptions;
  new (): CustomerSubscriptions;
};

interface CustomerSubscriptionsPanel extends Components.CustomerSubscriptionsPanel, HTMLElement {}
export const CustomerSubscriptionsPanel: {
  prototype: CustomerSubscriptionsPanel;
  new (): CustomerSubscriptionsPanel;
};

interface CustomerWarning extends Components.CustomerWarning, HTMLElement {}
export const CustomerWarning: {
  prototype: CustomerWarning;
  new (): CustomerWarning;
};

interface IgAddress extends Components.IgAddress, HTMLElement {}
export const IgAddress: {
  prototype: IgAddress;
  new (): IgAddress;
};

interface IgAddressDisplay extends Components.IgAddressDisplay, HTMLElement {}
export const IgAddressDisplay: {
  prototype: IgAddressDisplay;
  new (): IgAddressDisplay;
};

interface IgAddressInput extends Components.IgAddressInput, HTMLElement {}
export const IgAddressInput: {
  prototype: IgAddressInput;
  new (): IgAddressInput;
};

interface IgAddresses extends Components.IgAddresses, HTMLElement {}
export const IgAddresses: {
  prototype: IgAddresses;
  new (): IgAddresses;
};

interface IgAuthorizationAmount extends Components.IgAuthorizationAmount, HTMLElement {}
export const IgAuthorizationAmount: {
  prototype: IgAuthorizationAmount;
  new (): IgAuthorizationAmount;
};

interface IgAuthorizationAmountTable extends Components.IgAuthorizationAmountTable, HTMLElement {}
export const IgAuthorizationAmountTable: {
  prototype: IgAuthorizationAmountTable;
  new (): IgAuthorizationAmountTable;
};

interface IgAuthorizationCard extends Components.IgAuthorizationCard, HTMLElement {}
export const IgAuthorizationCard: {
  prototype: IgAuthorizationCard;
  new (): IgAuthorizationCard;
};

interface IgAuthorizationDetails extends Components.IgAuthorizationDetails, HTMLElement {}
export const IgAuthorizationDetails: {
  prototype: IgAuthorizationDetails;
  new (): IgAuthorizationDetails;
};

interface IgAuthorizationFooter extends Components.IgAuthorizationFooter, HTMLElement {}
export const IgAuthorizationFooter: {
  prototype: IgAuthorizationFooter;
  new (): IgAuthorizationFooter;
};

interface IgAuthorizationHistory extends Components.IgAuthorizationHistory, HTMLElement {}
export const IgAuthorizationHistory: {
  prototype: IgAuthorizationHistory;
  new (): IgAuthorizationHistory;
};

interface IgAuthorizationHistoryCapture extends Components.IgAuthorizationHistoryCapture, HTMLElement {}
export const IgAuthorizationHistoryCapture: {
  prototype: IgAuthorizationHistoryCapture;
  new (): IgAuthorizationHistoryCapture;
};

interface IgAuthorizationHistoryCreate extends Components.IgAuthorizationHistoryCreate, HTMLElement {}
export const IgAuthorizationHistoryCreate: {
  prototype: IgAuthorizationHistoryCreate;
  new (): IgAuthorizationHistoryCreate;
};

interface IgAuthorizationHistoryError extends Components.IgAuthorizationHistoryError, HTMLElement {}
export const IgAuthorizationHistoryError: {
  prototype: IgAuthorizationHistoryError;
  new (): IgAuthorizationHistoryError;
};

interface IgAuthorizationHistoryVerification extends Components.IgAuthorizationHistoryVerification, HTMLElement {}
export const IgAuthorizationHistoryVerification: {
  prototype: IgAuthorizationHistoryVerification;
  new (): IgAuthorizationHistoryVerification;
};

interface IgAuthorizationHistoryVoid extends Components.IgAuthorizationHistoryVoid, HTMLElement {}
export const IgAuthorizationHistoryVoid: {
  prototype: IgAuthorizationHistoryVoid;
  new (): IgAuthorizationHistoryVoid;
};

interface IgAuthorizationStatus extends Components.IgAuthorizationStatus, HTMLElement {}
export const IgAuthorizationStatus: {
  prototype: IgAuthorizationStatus;
  new (): IgAuthorizationStatus;
};

interface IgAuthorizationTable extends Components.IgAuthorizationTable, HTMLElement {}
export const IgAuthorizationTable: {
  prototype: IgAuthorizationTable;
  new (): IgAuthorizationTable;
};

interface IgAuthorizationTableRow extends Components.IgAuthorizationTableRow, HTMLElement {}
export const IgAuthorizationTableRow: {
  prototype: IgAuthorizationTableRow;
  new (): IgAuthorizationTableRow;
};

interface IgAuthorizations extends Components.IgAuthorizations, HTMLElement {}
export const IgAuthorizations: {
  prototype: IgAuthorizations;
  new (): IgAuthorizations;
};

interface IgAutocompleteInput extends Components.IgAutocompleteInput, HTMLElement {}
export const IgAutocompleteInput: {
  prototype: IgAutocompleteInput;
  new (): IgAutocompleteInput;
};

interface IgBalanceAdd extends Components.IgBalanceAdd, HTMLElement {}
export const IgBalanceAdd: {
  prototype: IgBalanceAdd;
  new (): IgBalanceAdd;
};

interface IgCardDetails extends Components.IgCardDetails, HTMLElement {}
export const IgCardDetails: {
  prototype: IgCardDetails;
  new (): IgCardDetails;
};

interface IgCheckoutDemo extends Components.IgCheckoutDemo, HTMLElement {}
export const IgCheckoutDemo: {
  prototype: IgCheckoutDemo;
  new (): IgCheckoutDemo;
};

interface IgCheckoutPayment extends Components.IgCheckoutPayment, HTMLElement {}
export const IgCheckoutPayment: {
  prototype: IgCheckoutPayment;
  new (): IgCheckoutPayment;
};

interface IgContact extends Components.IgContact, HTMLElement {}
export const IgContact: {
  prototype: IgContact;
  new (): IgContact;
};

interface IgCustomerActions extends Components.IgCustomerActions, HTMLElement {}
export const IgCustomerActions: {
  prototype: IgCustomerActions;
  new (): IgCustomerActions;
};

interface IgCustomerBalance extends Components.IgCustomerBalance, HTMLElement {}
export const IgCustomerBalance: {
  prototype: IgCustomerBalance;
  new (): IgCustomerBalance;
};

interface IgCustomerContact extends Components.IgCustomerContact, HTMLElement {}
export const IgCustomerContact: {
  prototype: IgCustomerContact;
  new (): IgCustomerContact;
};

interface IgCustomerCreate extends Components.IgCustomerCreate, HTMLElement {}
export const IgCustomerCreate: {
  prototype: IgCustomerCreate;
  new (): IgCustomerCreate;
};

interface IgCustomerCreatePopup extends Components.IgCustomerCreatePopup, HTMLElement {}
export const IgCustomerCreatePopup: {
  prototype: IgCustomerCreatePopup;
  new (): IgCustomerCreatePopup;
};

interface IgCustomerDetails extends Components.IgCustomerDetails, HTMLElement {}
export const IgCustomerDetails: {
  prototype: IgCustomerDetails;
  new (): IgCustomerDetails;
};

interface IgCustomerLimit extends Components.IgCustomerLimit, HTMLElement {}
export const IgCustomerLimit: {
  prototype: IgCustomerLimit;
  new (): IgCustomerLimit;
};

interface IgCustomerMethod extends Components.IgCustomerMethod, HTMLElement {}
export const IgCustomerMethod: {
  prototype: IgCustomerMethod;
  new (): IgCustomerMethod;
};

interface IgCustomerTableRow extends Components.IgCustomerTableRow, HTMLElement {}
export const IgCustomerTableRow: {
  prototype: IgCustomerTableRow;
  new (): IgCustomerTableRow;
};

interface IgCustomers extends Components.IgCustomers, HTMLElement {}
export const IgCustomers: {
  prototype: IgCustomers;
  new (): IgCustomers;
};

interface IgCustomersFooter extends Components.IgCustomersFooter, HTMLElement {}
export const IgCustomersFooter: {
  prototype: IgCustomersFooter;
  new (): IgCustomersFooter;
};

interface IgCustomersTable extends Components.IgCustomersTable, HTMLElement {}
export const IgCustomersTable: {
  prototype: IgCustomersTable;
  new (): IgCustomersTable;
};

interface IgDisplayAddress extends Components.IgDisplayAddress, HTMLElement {}
export const IgDisplayAddress: {
  prototype: IgDisplayAddress;
  new (): IgDisplayAddress;
};

interface IgDisplayEdit extends Components.IgDisplayEdit, HTMLElement {}
export const IgDisplayEdit: {
  prototype: IgDisplayEdit;
  new (): IgDisplayEdit;
};

interface IgDisplayItem extends Components.IgDisplayItem, HTMLElement {}
export const IgDisplayItem: {
  prototype: IgDisplayItem;
  new (): IgDisplayItem;
};

interface IgDisplayOrder extends Components.IgDisplayOrder, HTMLElement {}
export const IgDisplayOrder: {
  prototype: IgDisplayOrder;
  new (): IgDisplayOrder;
};

interface IgEmailAddress extends Components.IgEmailAddress, HTMLElement {}
export const IgEmailAddress: {
  prototype: IgEmailAddress;
  new (): IgEmailAddress;
};

interface IgEmailAddresses extends Components.IgEmailAddresses, HTMLElement {}
export const IgEmailAddresses: {
  prototype: IgEmailAddresses;
  new (): IgEmailAddresses;
};

interface IgEmailInput extends Components.IgEmailInput, HTMLElement {}
export const IgEmailInput: {
  prototype: IgEmailInput;
  new (): IgEmailInput;
};

interface IgEntryDetails extends Components.IgEntryDetails, HTMLElement {}
export const IgEntryDetails: {
  prototype: IgEntryDetails;
  new (): IgEntryDetails;
};

interface IgEntryTable extends Components.IgEntryTable, HTMLElement {}
export const IgEntryTable: {
  prototype: IgEntryTable;
  new (): IgEntryTable;
};

interface IgEntryTableRow extends Components.IgEntryTableRow, HTMLElement {}
export const IgEntryTableRow: {
  prototype: IgEntryTableRow;
  new (): IgEntryTableRow;
};

interface IgFilter extends Components.IgFilter, HTMLElement {}
export const IgFilter: {
  prototype: IgFilter;
  new (): IgFilter;
};

interface IgFutureDueDates extends Components.IgFutureDueDates, HTMLElement {}
export const IgFutureDueDates: {
  prototype: IgFutureDueDates;
  new (): IgFutureDueDates;
};

interface IgHistoryDetails extends Components.IgHistoryDetails, HTMLElement {}
export const IgHistoryDetails: {
  prototype: IgHistoryDetails;
  new (): IgHistoryDetails;
};

interface IgInstallmentDetails extends Components.IgInstallmentDetails, HTMLElement {}
export const IgInstallmentDetails: {
  prototype: IgInstallmentDetails;
  new (): IgInstallmentDetails;
};

interface IgInvoiceDetails extends Components.IgInvoiceDetails, HTMLElement {}
export const IgInvoiceDetails: {
  prototype: IgInvoiceDetails;
  new (): IgInvoiceDetails;
};

interface IgItem extends Components.IgItem, HTMLElement {}
export const IgItem: {
  prototype: IgItem;
  new (): IgItem;
};

interface IgItemInput extends Components.IgItemInput, HTMLElement {}
export const IgItemInput: {
  prototype: IgItemInput;
  new (): IgItemInput;
};

interface IgItemList extends Components.IgItemList, HTMLElement {}
export const IgItemList: {
  prototype: IgItemList;
  new (): IgItemList;
};

interface IgItemsDisplay extends Components.IgItemsDisplay, HTMLElement {}
export const IgItemsDisplay: {
  prototype: IgItemsDisplay;
  new (): IgItemsDisplay;
};

interface IgItemsList extends Components.IgItemsList, HTMLElement {}
export const IgItemsList: {
  prototype: IgItemsList;
  new (): IgItemsList;
};

interface IgLogDetails extends Components.IgLogDetails, HTMLElement {}
export const IgLogDetails: {
  prototype: IgLogDetails;
  new (): IgLogDetails;
};

interface IgLogFooter extends Components.IgLogFooter, HTMLElement {}
export const IgLogFooter: {
  prototype: IgLogFooter;
  new (): IgLogFooter;
};

interface IgLogMerchant extends Components.IgLogMerchant, HTMLElement {}
export const IgLogMerchant: {
  prototype: IgLogMerchant;
  new (): IgLogMerchant;
};

interface IgLogReference extends Components.IgLogReference, HTMLElement {}
export const IgLogReference: {
  prototype: IgLogReference;
  new (): IgLogReference;
};

interface IgLogTable extends Components.IgLogTable, HTMLElement {}
export const IgLogTable: {
  prototype: IgLogTable;
  new (): IgLogTable;
};

interface IgLogTableRow extends Components.IgLogTableRow, HTMLElement {}
export const IgLogTableRow: {
  prototype: IgLogTableRow;
  new (): IgLogTableRow;
};

interface IgLogs extends Components.IgLogs, HTMLElement {}
export const IgLogs: {
  prototype: IgLogs;
  new (): IgLogs;
};

interface IgMerchantAccountTable extends Components.IgMerchantAccountTable, HTMLElement {}
export const IgMerchantAccountTable: {
  prototype: IgMerchantAccountTable;
  new (): IgMerchantAccountTable;
};

interface IgMerchantDetails extends Components.IgMerchantDetails, HTMLElement {}
export const IgMerchantDetails: {
  prototype: IgMerchantDetails;
  new (): IgMerchantDetails;
};

interface IgMerchantFeeTable extends Components.IgMerchantFeeTable, HTMLElement {}
export const IgMerchantFeeTable: {
  prototype: IgMerchantFeeTable;
  new (): IgMerchantFeeTable;
};

interface IgMerchantFooter extends Components.IgMerchantFooter, HTMLElement {}
export const IgMerchantFooter: {
  prototype: IgMerchantFooter;
  new (): IgMerchantFooter;
};

interface IgMerchantInformation extends Components.IgMerchantInformation, HTMLElement {}
export const IgMerchantInformation: {
  prototype: IgMerchantInformation;
  new (): IgMerchantInformation;
};

interface IgMerchantRule extends Components.IgMerchantRule, HTMLElement {}
export const IgMerchantRule: {
  prototype: IgMerchantRule;
  new (): IgMerchantRule;
};

interface IgMerchantRuleInput extends Components.IgMerchantRuleInput, HTMLElement {}
export const IgMerchantRuleInput: {
  prototype: IgMerchantRuleInput;
  new (): IgMerchantRuleInput;
};

interface IgMerchantRules extends Components.IgMerchantRules, HTMLElement {}
export const IgMerchantRules: {
  prototype: IgMerchantRules;
  new (): IgMerchantRules;
};

interface IgMerchantSettlement extends Components.IgMerchantSettlement, HTMLElement {}
export const IgMerchantSettlement: {
  prototype: IgMerchantSettlement;
  new (): IgMerchantSettlement;
};

interface IgMerchantSingleInformation extends Components.IgMerchantSingleInformation, HTMLElement {}
export const IgMerchantSingleInformation: {
  prototype: IgMerchantSingleInformation;
  new (): IgMerchantSingleInformation;
};

interface IgMerchantTable extends Components.IgMerchantTable, HTMLElement {}
export const IgMerchantTable: {
  prototype: IgMerchantTable;
  new (): IgMerchantTable;
};

interface IgMerchantTableRow extends Components.IgMerchantTableRow, HTMLElement {}
export const IgMerchantTableRow: {
  prototype: IgMerchantTableRow;
  new (): IgMerchantTableRow;
};

interface IgMerchants extends Components.IgMerchants, HTMLElement {}
export const IgMerchants: {
  prototype: IgMerchants;
  new (): IgMerchants;
};

interface IgMonitorLogin extends Components.IgMonitorLogin, HTMLElement {}
export const IgMonitorLogin: {
  prototype: IgMonitorLogin;
  new (): IgMonitorLogin;
};

interface IgMonitorMerchantSettlements extends Components.IgMonitorMerchantSettlements, HTMLElement {}
export const IgMonitorMerchantSettlements: {
  prototype: IgMonitorMerchantSettlements;
  new (): IgMonitorMerchantSettlements;
};

interface IgMonitorSettlements extends Components.IgMonitorSettlements, HTMLElement {}
export const IgMonitorSettlements: {
  prototype: IgMonitorSettlements;
  new (): IgMonitorSettlements;
};

interface IgMonitorSettlementsDetails extends Components.IgMonitorSettlementsDetails, HTMLElement {}
export const IgMonitorSettlementsDetails: {
  prototype: IgMonitorSettlementsDetails;
  new (): IgMonitorSettlementsDetails;
};

interface IgMonitorSettlementsFees extends Components.IgMonitorSettlementsFees, HTMLElement {}
export const IgMonitorSettlementsFees: {
  prototype: IgMonitorSettlementsFees;
  new (): IgMonitorSettlementsFees;
};

interface IgMonitorSettlementsFooter extends Components.IgMonitorSettlementsFooter, HTMLElement {}
export const IgMonitorSettlementsFooter: {
  prototype: IgMonitorSettlementsFooter;
  new (): IgMonitorSettlementsFooter;
};

interface IgMonitorSettlementsTransactions extends Components.IgMonitorSettlementsTransactions, HTMLElement {}
export const IgMonitorSettlementsTransactions: {
  prototype: IgMonitorSettlementsTransactions;
  new (): IgMonitorSettlementsTransactions;
};

interface IgNumberDetails extends Components.IgNumberDetails, HTMLElement {}
export const IgNumberDetails: {
  prototype: IgNumberDetails;
  new (): IgNumberDetails;
};

interface IgOnboardForm extends Components.IgOnboardForm, HTMLElement {}
export const IgOnboardForm: {
  prototype: IgOnboardForm;
  new (): IgOnboardForm;
};

interface IgOrderContact extends Components.IgOrderContact, HTMLElement {}
export const IgOrderContact: {
  prototype: IgOrderContact;
  new (): IgOrderContact;
};

interface IgOrderEvents extends Components.IgOrderEvents, HTMLElement {}
export const IgOrderEvents: {
  prototype: IgOrderEvents;
  new (): IgOrderEvents;
};

interface IgOrderItems extends Components.IgOrderItems, HTMLElement {}
export const IgOrderItems: {
  prototype: IgOrderItems;
  new (): IgOrderItems;
};

interface IgOrderItemsQuantity extends Components.IgOrderItemsQuantity, HTMLElement {}
export const IgOrderItemsQuantity: {
  prototype: IgOrderItemsQuantity;
  new (): IgOrderItemsQuantity;
};

interface IgOrderItemsTotal extends Components.IgOrderItemsTotal, HTMLElement {}
export const IgOrderItemsTotal: {
  prototype: IgOrderItemsTotal;
  new (): IgOrderItemsTotal;
};

interface IgOrderPayment extends Components.IgOrderPayment, HTMLElement {}
export const IgOrderPayment: {
  prototype: IgOrderPayment;
  new (): IgOrderPayment;
};

interface IgOrders extends Components.IgOrders, HTMLElement {}
export const IgOrders: {
  prototype: IgOrders;
  new (): IgOrders;
};

interface IgOrdersActions extends Components.IgOrdersActions, HTMLElement {}
export const IgOrdersActions: {
  prototype: IgOrdersActions;
  new (): IgOrdersActions;
};

interface IgOrdersFooter extends Components.IgOrdersFooter, HTMLElement {}
export const IgOrdersFooter: {
  prototype: IgOrdersFooter;
  new (): IgOrdersFooter;
};

interface IgOrdersTable extends Components.IgOrdersTable, HTMLElement {}
export const IgOrdersTable: {
  prototype: IgOrdersTable;
  new (): IgOrdersTable;
};

interface IgOrdersTableDetails extends Components.IgOrdersTableDetails, HTMLElement {}
export const IgOrdersTableDetails: {
  prototype: IgOrdersTableDetails;
  new (): IgOrdersTableDetails;
};

interface IgOrdersTableRow extends Components.IgOrdersTableRow, HTMLElement {}
export const IgOrdersTableRow: {
  prototype: IgOrdersTableRow;
  new (): IgOrdersTableRow;
};

interface IgPaymentMethod extends Components.IgPaymentMethod, HTMLElement {}
export const IgPaymentMethod: {
  prototype: IgPaymentMethod;
  new (): IgPaymentMethod;
};

interface IgPaymentMethodAdd extends Components.IgPaymentMethodAdd, HTMLElement {}
export const IgPaymentMethodAdd: {
  prototype: IgPaymentMethodAdd;
  new (): IgPaymentMethodAdd;
};

interface IgPaymentMethods extends Components.IgPaymentMethods, HTMLElement {}
export const IgPaymentMethods: {
  prototype: IgPaymentMethods;
  new (): IgPaymentMethods;
};

interface IgPaymentOption extends Components.IgPaymentOption, HTMLElement {}
export const IgPaymentOption: {
  prototype: IgPaymentOption;
  new (): IgPaymentOption;
};

interface IgPaymentOptions extends Components.IgPaymentOptions, HTMLElement {}
export const IgPaymentOptions: {
  prototype: IgPaymentOptions;
  new (): IgPaymentOptions;
};

interface IgPhoneNumber extends Components.IgPhoneNumber, HTMLElement {}
export const IgPhoneNumber: {
  prototype: IgPhoneNumber;
  new (): IgPhoneNumber;
};

interface IgPhoneNumberInput extends Components.IgPhoneNumberInput, HTMLElement {}
export const IgPhoneNumberInput: {
  prototype: IgPhoneNumberInput;
  new (): IgPhoneNumberInput;
};

interface IgPhoneNumbers extends Components.IgPhoneNumbers, HTMLElement {}
export const IgPhoneNumbers: {
  prototype: IgPhoneNumbers;
  new (): IgPhoneNumbers;
};

interface IgPortalSettlement extends Components.IgPortalSettlement, HTMLElement {}
export const IgPortalSettlement: {
  prototype: IgPortalSettlement;
  new (): IgPortalSettlement;
};

interface IgPortalSettlementFooter extends Components.IgPortalSettlementFooter, HTMLElement {}
export const IgPortalSettlementFooter: {
  prototype: IgPortalSettlementFooter;
  new (): IgPortalSettlementFooter;
};

interface IgPortalSettlementOrders extends Components.IgPortalSettlementOrders, HTMLElement {}
export const IgPortalSettlementOrders: {
  prototype: IgPortalSettlementOrders;
  new (): IgPortalSettlementOrders;
};

interface IgPortalSettlementTable extends Components.IgPortalSettlementTable, HTMLElement {}
export const IgPortalSettlementTable: {
  prototype: IgPortalSettlementTable;
  new (): IgPortalSettlementTable;
};

interface IgPortalSettlements extends Components.IgPortalSettlements, HTMLElement {}
export const IgPortalSettlements: {
  prototype: IgPortalSettlements;
  new (): IgPortalSettlements;
};

interface IgRedo extends Components.IgRedo, HTMLElement {}
export const IgRedo: {
  prototype: IgRedo;
  new (): IgRedo;
};

interface IgSchedule extends Components.IgSchedule, HTMLElement {}
export const IgSchedule: {
  prototype: IgSchedule;
  new (): IgSchedule;
};

interface IgSchemeLogotype extends Components.IgSchemeLogotype, HTMLElement {}
export const IgSchemeLogotype: {
  prototype: IgSchemeLogotype;
  new (): IgSchemeLogotype;
};

interface IgSelectOffset extends Components.IgSelectOffset, HTMLElement {}
export const IgSelectOffset: {
  prototype: IgSelectOffset;
  new (): IgSelectOffset;
};

interface IgSingleMerchant extends Components.IgSingleMerchant, HTMLElement {}
export const IgSingleMerchant: {
  prototype: IgSingleMerchant;
  new (): IgSingleMerchant;
};

interface IgStatus extends Components.IgStatus, HTMLElement {}
export const IgStatus: {
  prototype: IgStatus;
  new (): IgStatus;
};

interface IgStatusChange extends Components.IgStatusChange, HTMLElement {}
export const IgStatusChange: {
  prototype: IgStatusChange;
  new (): IgStatusChange;
};

interface IgSubscriptionCreate extends Components.IgSubscriptionCreate, HTMLElement {}
export const IgSubscriptionCreate: {
  prototype: IgSubscriptionCreate;
  new (): IgSubscriptionCreate;
};

interface IgSubscriptionDetails extends Components.IgSubscriptionDetails, HTMLElement {}
export const IgSubscriptionDetails: {
  prototype: IgSubscriptionDetails;
  new (): IgSubscriptionDetails;
};

interface IgSubscriptionTable extends Components.IgSubscriptionTable, HTMLElement {}
export const IgSubscriptionTable: {
  prototype: IgSubscriptionTable;
  new (): IgSubscriptionTable;
};

interface IgSubscriptionTableRow extends Components.IgSubscriptionTableRow, HTMLElement {}
export const IgSubscriptionTableRow: {
  prototype: IgSubscriptionTableRow;
  new (): IgSubscriptionTableRow;
};

interface IgTable extends Components.IgTable, HTMLElement {}
export const IgTable: {
  prototype: IgTable;
  new (): IgTable;
};

interface IgTableRow extends Components.IgTableRow, HTMLElement {}
export const IgTableRow: {
  prototype: IgTableRow;
  new (): IgTableRow;
};

interface IgTotalAmount extends Components.IgTotalAmount, HTMLElement {}
export const IgTotalAmount: {
  prototype: IgTotalAmount;
  new (): IgTotalAmount;
};

interface IgUserMenu extends Components.IgUserMenu, HTMLElement {}
export const IgUserMenu: {
  prototype: IgUserMenu;
  new (): IgUserMenu;
};

interface IntergiroCardInput extends Components.IntergiroCardInput, HTMLElement {}
export const IntergiroCardInput: {
  prototype: IntergiroCardInput;
  new (): IntergiroCardInput;
};

interface IntergiroCheckout extends Components.IntergiroCheckout, HTMLElement {}
export const IntergiroCheckout: {
  prototype: IntergiroCheckout;
  new (): IntergiroCheckout;
};

interface IntergiroCustomer extends Components.IntergiroCustomer, HTMLElement {}
export const IntergiroCustomer: {
  prototype: IntergiroCustomer;
  new (): IntergiroCustomer;
};

interface IntergiroMonitor extends Components.IntergiroMonitor, HTMLElement {}
export const IntergiroMonitor: {
  prototype: IntergiroMonitor;
  new (): IntergiroMonitor;
};

interface IntergiroOnboard extends Components.IntergiroOnboard, HTMLElement {}
export const IntergiroOnboard: {
  prototype: IntergiroOnboard;
  new (): IntergiroOnboard;
};

interface MerchantTerms extends Components.MerchantTerms, HTMLElement {}
export const MerchantTerms: {
  prototype: MerchantTerms;
  new (): MerchantTerms;
};

interface OnboardDemo extends Components.OnboardDemo, HTMLElement {}
export const OnboardDemo: {
  prototype: OnboardDemo;
  new (): OnboardDemo;
};

interface PayfuncCardInput extends Components.PayfuncCardInput, HTMLElement {}
export const PayfuncCardInput: {
  prototype: PayfuncCardInput;
  new (): PayfuncCardInput;
};

interface PayfuncCheckout extends Components.PayfuncCheckout, HTMLElement {}
export const PayfuncCheckout: {
  prototype: PayfuncCheckout;
  new (): PayfuncCheckout;
};

interface PayfuncLogotypes extends Components.PayfuncLogotypes, HTMLElement {}
export const PayfuncLogotypes: {
  prototype: PayfuncLogotypes;
  new (): PayfuncLogotypes;
};

interface PayfuncMonitor extends Components.PayfuncMonitor, HTMLElement {}
export const PayfuncMonitor: {
  prototype: PayfuncMonitor;
  new (): PayfuncMonitor;
};

interface PayfuncOnboard extends Components.PayfuncOnboard, HTMLElement {}
export const PayfuncOnboard: {
  prototype: PayfuncOnboard;
  new (): PayfuncOnboard;
};

interface PayfuncPortal extends Components.PayfuncPortal, HTMLElement {}
export const PayfuncPortal: {
  prototype: PayfuncPortal;
  new (): PayfuncPortal;
};

interface PortalCreateOrder extends Components.PortalCreateOrder, HTMLElement {}
export const PortalCreateOrder: {
  prototype: PortalCreateOrder;
  new (): PortalCreateOrder;
};

interface PortalDeferView extends Components.PortalDeferView, HTMLElement {}
export const PortalDeferView: {
  prototype: PortalDeferView;
  new (): PortalDeferView;
};

interface PortalDisplayDefer extends Components.PortalDisplayDefer, HTMLElement {}
export const PortalDisplayDefer: {
  prototype: PortalDisplayDefer;
  new (): PortalDisplayDefer;
};

interface PortalDisplayDeferList extends Components.PortalDisplayDeferList, HTMLElement {}
export const PortalDisplayDeferList: {
  prototype: PortalDisplayDeferList;
  new (): PortalDisplayDeferList;
};

interface PortalLogin extends Components.PortalLogin, HTMLElement {}
export const PortalLogin: {
  prototype: PortalLogin;
  new (): PortalLogin;
};

/**
 * Utility to define all custom elements within this package using the tag name provided in the component's source. 
 * When defining each custom element, it will also check it's safe to define by:
 *
 * 1. Ensuring the "customElements" registry is available in the global context (window).
 * 2. The component tag name is not already defined.
 *
 * Use the standard [customElements.define()](https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/define) 
 * method instead to define custom elements individually, or to provide a different tag name.
 */
export declare const defineCustomElements: (opts?: any) => void;

/**
 * Used to manually set the base path where assets can be found.
 * If the script is used as "module", it's recommended to use "import.meta.url",
 * such as "setAssetPath(import.meta.url)". Other options include
 * "setAssetPath(document.currentScript.src)", or using a bundler's replace plugin to
 * dynamically set the path at build time, such as "setAssetPath(process.env.ASSET_PATH)".
 * But do note that this configuration depends on how your script is bundled, or lack of
 * bunding, and where your assets can be loaded from. Additionally custom bundling
 * will have to ensure the static assets are copied to its build directory.
 */
export declare const setAssetPath: (path: string) => void;

export interface SetPlatformOptions {
  raf?: (c: FrameRequestCallback) => number;
  ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
  rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
  ce?: (eventName: string, opts?: any) => CustomEvent;
}
export declare const setPlatformOptions: (opts: SetPlatformOptions) => void;

export type { Components, JSX };

export * from '../types';
