'use client';

/**
 * This file was automatically generated by the Stencil React Output Target.
 * Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
 */

/* eslint-disable */

import type { EventName, StencilReactComponent } from '@stencil/react-output-target/runtime';
import { createComponent } from '@stencil/react-output-target/runtime';
import React from 'react';
import { MvxAngleLeftIcon as MvxAngleLeftIconElement, defineCustomElement as defineMvxAngleLeftIcon } from "../../dist/types/../web-components/mvx-angle-left-icon.js";
import { MvxAngleRightIcon as MvxAngleRightIconElement, defineCustomElement as defineMvxAngleRightIcon } from "../../dist/types/../web-components/mvx-angle-right-icon.js";
import { MvxAnglesLeftIcon as MvxAnglesLeftIconElement, defineCustomElement as defineMvxAnglesLeftIcon } from "../../dist/types/../web-components/mvx-angles-left-icon.js";
import { MvxAnglesRightIcon as MvxAnglesRightIconElement, defineCustomElement as defineMvxAnglesRightIcon } from "../../dist/types/../web-components/mvx-angles-right-icon.js";
import { MvxArrowUpRightIcon as MvxArrowUpRightIconElement, defineCustomElement as defineMvxArrowUpRightIcon } from "../../dist/types/../web-components/mvx-arrow-up-right-icon.js";
import { MvxBackArrowIcon as MvxBackArrowIconElement, defineCustomElement as defineMvxBackArrowIcon } from "../../dist/types/../web-components/mvx-back-arrow-icon.js";
import { MvxCloseIcon as MvxCloseIconElement, defineCustomElement as defineMvxCloseIcon } from "../../dist/types/../web-components/mvx-close-icon.js";
import { MvxCopyButton as MvxCopyButtonElement, defineCustomElement as defineMvxCopyButton } from "../../dist/types/../web-components/mvx-copy-button.js";
import { MvxDefaultTransactionIconLarge as MvxDefaultTransactionIconLargeElement, defineCustomElement as defineMvxDefaultTransactionIconLarge } from "../../dist/types/../web-components/mvx-default-transaction-icon-large.js";
import { MvxDefaultTransactionIconSmall as MvxDefaultTransactionIconSmallElement, defineCustomElement as defineMvxDefaultTransactionIconSmall } from "../../dist/types/../web-components/mvx-default-transaction-icon-small.js";
import { MvxExplorerLink as MvxExplorerLinkElement, defineCustomElement as defineMvxExplorerLink } from "../../dist/types/../web-components/mvx-explorer-link.js";
import { MvxExtensionProviderIcon as MvxExtensionProviderIconElement, defineCustomElement as defineMvxExtensionProviderIcon } from "../../dist/types/../web-components/mvx-extension-provider-icon.js";
import { MvxFaIcon as MvxFaIconElement, defineCustomElement as defineMvxFaIcon } from "../../dist/types/../web-components/mvx-fa-icon.js";
import { MvxFormatAmount as MvxFormatAmountElement, defineCustomElement as defineMvxFormatAmount } from "../../dist/types/../web-components/mvx-format-amount.js";
import { MvxGenericModal as MvxGenericModalElement, defineCustomElement as defineMvxGenericModal } from "../../dist/types/../web-components/mvx-generic-modal.js";
import { MvxGenericSpinner as MvxGenericSpinnerElement, defineCustomElement as defineMvxGenericSpinner } from "../../dist/types/../web-components/mvx-generic-spinner.js";
import { MvxLedgerAddresses as MvxLedgerAddressesElement, defineCustomElement as defineMvxLedgerAddresses } from "../../dist/types/../web-components/mvx-ledger-addresses.js";
import { MvxLedgerConfirm as MvxLedgerConfirmElement, defineCustomElement as defineMvxLedgerConfirm } from "../../dist/types/../web-components/mvx-ledger-confirm.js";
import { MvxLedgerIcon as MvxLedgerIconElement, defineCustomElement as defineMvxLedgerIcon } from "../../dist/types/../web-components/mvx-ledger-icon.js";
import { MvxLedgerIntro as MvxLedgerIntroElement, defineCustomElement as defineMvxLedgerIntro } from "../../dist/types/../web-components/mvx-ledger-intro.js";
import { MvxLedgerProviderIcon as MvxLedgerProviderIconElement, defineCustomElement as defineMvxLedgerProviderIcon } from "../../dist/types/../web-components/mvx-ledger-provider-icon.js";
import { MvxMagnifyingGlassIcon as MvxMagnifyingGlassIconElement, defineCustomElement as defineMvxMagnifyingGlassIcon } from "../../dist/types/../web-components/mvx-magnifying-glass-icon.js";
import { MvxMetamaskProviderIcon as MvxMetamaskProviderIconElement, defineCustomElement as defineMvxMetamaskProviderIcon } from "../../dist/types/../web-components/mvx-metamask-provider-icon.js";
import { MvxMultiversxLogoIcon as MvxMultiversxLogoIconElement, defineCustomElement as defineMvxMultiversxLogoIcon } from "../../dist/types/../web-components/mvx-multiversx-logo-icon.js";
import { MvxNotificationsFeed as MvxNotificationsFeedElement, defineCustomElement as defineMvxNotificationsFeed } from "../../dist/types/../web-components/mvx-notifications-feed.js";
import { MvxPaginationEllipsisForm as MvxPaginationEllipsisFormElement, defineCustomElement as defineMvxPaginationEllipsisForm } from "../../dist/types/../web-components/mvx-pagination-ellipsis-form.js";
import { MvxPaginationEllipsis as MvxPaginationEllipsisElement, defineCustomElement as defineMvxPaginationEllipsis } from "../../dist/types/../web-components/mvx-pagination-ellipsis.js";
import { MvxPagination as MvxPaginationElement, defineCustomElement as defineMvxPagination } from "../../dist/types/../web-components/mvx-pagination.js";
import { MvxPasskeyProviderIcon as MvxPasskeyProviderIconElement, defineCustomElement as defineMvxPasskeyProviderIcon } from "../../dist/types/../web-components/mvx-passkey-provider-icon.js";
import { MvxSidePanel as MvxSidePanelElement, defineCustomElement as defineMvxSidePanel } from "../../dist/types/../web-components/mvx-side-panel.js";
import { MvxSpinnerIcon as MvxSpinnerIconElement, defineCustomElement as defineMvxSpinnerIcon } from "../../dist/types/../web-components/mvx-spinner-icon.js";
import { MvxTooltip as MvxTooltipElement, defineCustomElement as defineMvxTooltip } from "../../dist/types/../web-components/mvx-tooltip.js";
import { MvxTransactionAccountName as MvxTransactionAccountNameElement, defineCustomElement as defineMvxTransactionAccountName } from "../../dist/types/../web-components/mvx-transaction-account-name.js";
import { MvxTransactionAccount as MvxTransactionAccountElement, defineCustomElement as defineMvxTransactionAccount } from "../../dist/types/../web-components/mvx-transaction-account.js";
import { MvxTransactionAge as MvxTransactionAgeElement, defineCustomElement as defineMvxTransactionAge } from "../../dist/types/../web-components/mvx-transaction-age.js";
import { MvxTransactionDirectionBadge as MvxTransactionDirectionBadgeElement, defineCustomElement as defineMvxTransactionDirectionBadge } from "../../dist/types/../web-components/mvx-transaction-direction-badge.js";
import { MvxTransactionHash as MvxTransactionHashElement, defineCustomElement as defineMvxTransactionHash } from "../../dist/types/../web-components/mvx-transaction-hash.js";
import { MvxTransactionIcon as MvxTransactionIconElement, defineCustomElement as defineMvxTransactionIcon } from "../../dist/types/../web-components/mvx-transaction-icon.js";
import { MvxTransactionListItem as MvxTransactionListItemElement, defineCustomElement as defineMvxTransactionListItem } from "../../dist/types/../web-components/mvx-transaction-list-item.js";
import { MvxTransactionMethod as MvxTransactionMethodElement, defineCustomElement as defineMvxTransactionMethod } from "../../dist/types/../web-components/mvx-transaction-method.js";
import { MvxTransactionShards as MvxTransactionShardsElement, defineCustomElement as defineMvxTransactionShards } from "../../dist/types/../web-components/mvx-transaction-shards.js";
import { MvxTransactionValue as MvxTransactionValueElement, defineCustomElement as defineMvxTransactionValue } from "../../dist/types/../web-components/mvx-transaction-value.js";
import { MvxTransactionsTable as MvxTransactionsTableElement, defineCustomElement as defineMvxTransactionsTable } from "../../dist/types/../web-components/mvx-transactions-table.js";
import { MvxTriangularWarningIcon as MvxTriangularWarningIconElement, defineCustomElement as defineMvxTriangularWarningIcon } from "../../dist/types/../web-components/mvx-triangular-warning-icon.js";
import { MvxTrimText as MvxTrimTextElement, defineCustomElement as defineMvxTrimText } from "../../dist/types/../web-components/mvx-trim-text.js";
import { MvxUnlockButton as MvxUnlockButtonElement, defineCustomElement as defineMvxUnlockButton } from "../../dist/types/../web-components/mvx-unlock-button.js";
import { MvxUnlockProviderButton as MvxUnlockProviderButtonElement, defineCustomElement as defineMvxUnlockProviderButton } from "../../dist/types/../web-components/mvx-unlock-provider-button.js";
import { MvxUnlockProviderIntro as MvxUnlockProviderIntroElement, defineCustomElement as defineMvxUnlockProviderIntro } from "../../dist/types/../web-components/mvx-unlock-provider-intro.js";
import { MvxWalletConnectFlow as MvxWalletConnectFlowElement, defineCustomElement as defineMvxWalletConnectFlow } from "../../dist/types/../web-components/mvx-wallet-connect-flow.js";
import { MvxWalletProviderIcon as MvxWalletProviderIconElement, defineCustomElement as defineMvxWalletProviderIcon } from "../../dist/types/../web-components/mvx-wallet-provider-icon.js";
import { MvxXaliasProviderIcon as MvxXaliasProviderIconElement, defineCustomElement as defineMvxXaliasProviderIcon } from "../../dist/types/../web-components/mvx-xalias-provider-icon.js";
import { MvxXportalDownloadQrIcon as MvxXportalDownloadQrIconElement, defineCustomElement as defineMvxXportalDownloadQrIcon } from "../../dist/types/../web-components/mvx-xportal-download-qr-icon.js";
import { MvxXportalQrCodePreloader as MvxXportalQrCodePreloaderElement, defineCustomElement as defineMvxXportalQrCodePreloader } from "../../dist/types/../web-components/mvx-xportal-qr-code-preloader.js";

type MvxAngleLeftIconEvents = NonNullable<unknown>;

export const MvxAngleLeftIcon: StencilReactComponent<MvxAngleLeftIconElement, MvxAngleLeftIconEvents> = /*@__PURE__*/ createComponent<MvxAngleLeftIconElement, MvxAngleLeftIconEvents>({
    tagName: 'mvx-angle-left-icon',
    elementClass: MvxAngleLeftIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxAngleLeftIconEvents,
    defineCustomElement: defineMvxAngleLeftIcon
});

type MvxAngleRightIconEvents = NonNullable<unknown>;

export const MvxAngleRightIcon: StencilReactComponent<MvxAngleRightIconElement, MvxAngleRightIconEvents> = /*@__PURE__*/ createComponent<MvxAngleRightIconElement, MvxAngleRightIconEvents>({
    tagName: 'mvx-angle-right-icon',
    elementClass: MvxAngleRightIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxAngleRightIconEvents,
    defineCustomElement: defineMvxAngleRightIcon
});

type MvxAnglesLeftIconEvents = NonNullable<unknown>;

export const MvxAnglesLeftIcon: StencilReactComponent<MvxAnglesLeftIconElement, MvxAnglesLeftIconEvents> = /*@__PURE__*/ createComponent<MvxAnglesLeftIconElement, MvxAnglesLeftIconEvents>({
    tagName: 'mvx-angles-left-icon',
    elementClass: MvxAnglesLeftIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxAnglesLeftIconEvents,
    defineCustomElement: defineMvxAnglesLeftIcon
});

type MvxAnglesRightIconEvents = NonNullable<unknown>;

export const MvxAnglesRightIcon: StencilReactComponent<MvxAnglesRightIconElement, MvxAnglesRightIconEvents> = /*@__PURE__*/ createComponent<MvxAnglesRightIconElement, MvxAnglesRightIconEvents>({
    tagName: 'mvx-angles-right-icon',
    elementClass: MvxAnglesRightIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxAnglesRightIconEvents,
    defineCustomElement: defineMvxAnglesRightIcon
});

type MvxArrowUpRightIconEvents = NonNullable<unknown>;

export const MvxArrowUpRightIcon: StencilReactComponent<MvxArrowUpRightIconElement, MvxArrowUpRightIconEvents> = /*@__PURE__*/ createComponent<MvxArrowUpRightIconElement, MvxArrowUpRightIconEvents>({
    tagName: 'mvx-arrow-up-right-icon',
    elementClass: MvxArrowUpRightIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxArrowUpRightIconEvents,
    defineCustomElement: defineMvxArrowUpRightIcon
});

type MvxBackArrowIconEvents = NonNullable<unknown>;

export const MvxBackArrowIcon: StencilReactComponent<MvxBackArrowIconElement, MvxBackArrowIconEvents> = /*@__PURE__*/ createComponent<MvxBackArrowIconElement, MvxBackArrowIconEvents>({
    tagName: 'mvx-back-arrow-icon',
    elementClass: MvxBackArrowIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxBackArrowIconEvents,
    defineCustomElement: defineMvxBackArrowIcon
});

type MvxCloseIconEvents = NonNullable<unknown>;

export const MvxCloseIcon: StencilReactComponent<MvxCloseIconElement, MvxCloseIconEvents> = /*@__PURE__*/ createComponent<MvxCloseIconElement, MvxCloseIconEvents>({
    tagName: 'mvx-close-icon',
    elementClass: MvxCloseIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxCloseIconEvents,
    defineCustomElement: defineMvxCloseIcon
});

type MvxCopyButtonEvents = NonNullable<unknown>;

export const MvxCopyButton: StencilReactComponent<MvxCopyButtonElement, MvxCopyButtonEvents> = /*@__PURE__*/ createComponent<MvxCopyButtonElement, MvxCopyButtonEvents>({
    tagName: 'mvx-copy-button',
    elementClass: MvxCopyButtonElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxCopyButtonEvents,
    defineCustomElement: defineMvxCopyButton
});

type MvxDefaultTransactionIconLargeEvents = NonNullable<unknown>;

export const MvxDefaultTransactionIconLarge: StencilReactComponent<MvxDefaultTransactionIconLargeElement, MvxDefaultTransactionIconLargeEvents> = /*@__PURE__*/ createComponent<MvxDefaultTransactionIconLargeElement, MvxDefaultTransactionIconLargeEvents>({
    tagName: 'mvx-default-transaction-icon-large',
    elementClass: MvxDefaultTransactionIconLargeElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxDefaultTransactionIconLargeEvents,
    defineCustomElement: defineMvxDefaultTransactionIconLarge
});

type MvxDefaultTransactionIconSmallEvents = NonNullable<unknown>;

export const MvxDefaultTransactionIconSmall: StencilReactComponent<MvxDefaultTransactionIconSmallElement, MvxDefaultTransactionIconSmallEvents> = /*@__PURE__*/ createComponent<MvxDefaultTransactionIconSmallElement, MvxDefaultTransactionIconSmallEvents>({
    tagName: 'mvx-default-transaction-icon-small',
    elementClass: MvxDefaultTransactionIconSmallElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxDefaultTransactionIconSmallEvents,
    defineCustomElement: defineMvxDefaultTransactionIconSmall
});

type MvxExplorerLinkEvents = NonNullable<unknown>;

export const MvxExplorerLink: StencilReactComponent<MvxExplorerLinkElement, MvxExplorerLinkEvents> = /*@__PURE__*/ createComponent<MvxExplorerLinkElement, MvxExplorerLinkEvents>({
    tagName: 'mvx-explorer-link',
    elementClass: MvxExplorerLinkElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxExplorerLinkEvents,
    defineCustomElement: defineMvxExplorerLink
});

type MvxExtensionProviderIconEvents = NonNullable<unknown>;

export const MvxExtensionProviderIcon: StencilReactComponent<MvxExtensionProviderIconElement, MvxExtensionProviderIconEvents> = /*@__PURE__*/ createComponent<MvxExtensionProviderIconElement, MvxExtensionProviderIconEvents>({
    tagName: 'mvx-extension-provider-icon',
    elementClass: MvxExtensionProviderIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxExtensionProviderIconEvents,
    defineCustomElement: defineMvxExtensionProviderIcon
});

type MvxFaIconEvents = NonNullable<unknown>;

export const MvxFaIcon: StencilReactComponent<MvxFaIconElement, MvxFaIconEvents> = /*@__PURE__*/ createComponent<MvxFaIconElement, MvxFaIconEvents>({
    tagName: 'mvx-fa-icon',
    elementClass: MvxFaIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxFaIconEvents,
    defineCustomElement: defineMvxFaIcon
});

type MvxFormatAmountEvents = NonNullable<unknown>;

export const MvxFormatAmount: StencilReactComponent<MvxFormatAmountElement, MvxFormatAmountEvents> = /*@__PURE__*/ createComponent<MvxFormatAmountElement, MvxFormatAmountEvents>({
    tagName: 'mvx-format-amount',
    elementClass: MvxFormatAmountElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxFormatAmountEvents,
    defineCustomElement: defineMvxFormatAmount
});

type MvxGenericModalEvents = { onClose: EventName<CustomEvent<any>> };

export const MvxGenericModal: StencilReactComponent<MvxGenericModalElement, MvxGenericModalEvents> = /*@__PURE__*/ createComponent<MvxGenericModalElement, MvxGenericModalEvents>({
    tagName: 'mvx-generic-modal',
    elementClass: MvxGenericModalElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: { onClose: 'close' } as MvxGenericModalEvents,
    defineCustomElement: defineMvxGenericModal
});

type MvxGenericSpinnerEvents = NonNullable<unknown>;

export const MvxGenericSpinner: StencilReactComponent<MvxGenericSpinnerElement, MvxGenericSpinnerEvents> = /*@__PURE__*/ createComponent<MvxGenericSpinnerElement, MvxGenericSpinnerEvents>({
    tagName: 'mvx-generic-spinner',
    elementClass: MvxGenericSpinnerElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxGenericSpinnerEvents,
    defineCustomElement: defineMvxGenericSpinner
});

type MvxLedgerAddressesEvents = {
    onAccessWallet: EventName<CustomEvent<any>>,
    onSelectAccount: EventName<CustomEvent<any>>,
    onPageChange: EventName<CustomEvent<number>>
};

export const MvxLedgerAddresses: StencilReactComponent<MvxLedgerAddressesElement, MvxLedgerAddressesEvents> = /*@__PURE__*/ createComponent<MvxLedgerAddressesElement, MvxLedgerAddressesEvents>({
    tagName: 'mvx-ledger-addresses',
    elementClass: MvxLedgerAddressesElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {
        onAccessWallet: 'accessWallet',
        onSelectAccount: 'selectAccount',
        onPageChange: 'pageChange'
    } as MvxLedgerAddressesEvents,
    defineCustomElement: defineMvxLedgerAddresses
});

type MvxLedgerConfirmEvents = NonNullable<unknown>;

export const MvxLedgerConfirm: StencilReactComponent<MvxLedgerConfirmElement, MvxLedgerConfirmEvents> = /*@__PURE__*/ createComponent<MvxLedgerConfirmElement, MvxLedgerConfirmEvents>({
    tagName: 'mvx-ledger-confirm',
    elementClass: MvxLedgerConfirmElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxLedgerConfirmEvents,
    defineCustomElement: defineMvxLedgerConfirm
});

type MvxLedgerIconEvents = NonNullable<unknown>;

export const MvxLedgerIcon: StencilReactComponent<MvxLedgerIconElement, MvxLedgerIconEvents> = /*@__PURE__*/ createComponent<MvxLedgerIconElement, MvxLedgerIconEvents>({
    tagName: 'mvx-ledger-icon',
    elementClass: MvxLedgerIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxLedgerIconEvents,
    defineCustomElement: defineMvxLedgerIcon
});

type MvxLedgerIntroEvents = { onConnect: EventName<CustomEvent<any>> };

export const MvxLedgerIntro: StencilReactComponent<MvxLedgerIntroElement, MvxLedgerIntroEvents> = /*@__PURE__*/ createComponent<MvxLedgerIntroElement, MvxLedgerIntroEvents>({
    tagName: 'mvx-ledger-intro',
    elementClass: MvxLedgerIntroElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: { onConnect: 'connect' } as MvxLedgerIntroEvents,
    defineCustomElement: defineMvxLedgerIntro
});

type MvxLedgerProviderIconEvents = NonNullable<unknown>;

export const MvxLedgerProviderIcon: StencilReactComponent<MvxLedgerProviderIconElement, MvxLedgerProviderIconEvents> = /*@__PURE__*/ createComponent<MvxLedgerProviderIconElement, MvxLedgerProviderIconEvents>({
    tagName: 'mvx-ledger-provider-icon',
    elementClass: MvxLedgerProviderIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxLedgerProviderIconEvents,
    defineCustomElement: defineMvxLedgerProviderIcon
});

type MvxMagnifyingGlassIconEvents = NonNullable<unknown>;

export const MvxMagnifyingGlassIcon: StencilReactComponent<MvxMagnifyingGlassIconElement, MvxMagnifyingGlassIconEvents> = /*@__PURE__*/ createComponent<MvxMagnifyingGlassIconElement, MvxMagnifyingGlassIconEvents>({
    tagName: 'mvx-magnifying-glass-icon',
    elementClass: MvxMagnifyingGlassIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxMagnifyingGlassIconEvents,
    defineCustomElement: defineMvxMagnifyingGlassIcon
});

type MvxMetamaskProviderIconEvents = NonNullable<unknown>;

export const MvxMetamaskProviderIcon: StencilReactComponent<MvxMetamaskProviderIconElement, MvxMetamaskProviderIconEvents> = /*@__PURE__*/ createComponent<MvxMetamaskProviderIconElement, MvxMetamaskProviderIconEvents>({
    tagName: 'mvx-metamask-provider-icon',
    elementClass: MvxMetamaskProviderIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxMetamaskProviderIconEvents,
    defineCustomElement: defineMvxMetamaskProviderIcon
});

type MvxMultiversxLogoIconEvents = NonNullable<unknown>;

export const MvxMultiversxLogoIcon: StencilReactComponent<MvxMultiversxLogoIconElement, MvxMultiversxLogoIconEvents> = /*@__PURE__*/ createComponent<MvxMultiversxLogoIconElement, MvxMultiversxLogoIconEvents>({
    tagName: 'mvx-multiversx-logo-icon',
    elementClass: MvxMultiversxLogoIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxMultiversxLogoIconEvents,
    defineCustomElement: defineMvxMultiversxLogoIcon
});

type MvxNotificationsFeedEvents = NonNullable<unknown>;

export const MvxNotificationsFeed: StencilReactComponent<MvxNotificationsFeedElement, MvxNotificationsFeedEvents> = /*@__PURE__*/ createComponent<MvxNotificationsFeedElement, MvxNotificationsFeedEvents>({
    tagName: 'mvx-notifications-feed',
    elementClass: MvxNotificationsFeedElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxNotificationsFeedEvents,
    defineCustomElement: defineMvxNotificationsFeed
});

type MvxPaginationEvents = { onPageChange: EventName<CustomEvent<number>> };

export const MvxPagination: StencilReactComponent<MvxPaginationElement, MvxPaginationEvents> = /*@__PURE__*/ createComponent<MvxPaginationElement, MvxPaginationEvents>({
    tagName: 'mvx-pagination',
    elementClass: MvxPaginationElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: { onPageChange: 'pageChange' } as MvxPaginationEvents,
    defineCustomElement: defineMvxPagination
});

type MvxPaginationEllipsisEvents = NonNullable<unknown>;

export const MvxPaginationEllipsis: StencilReactComponent<MvxPaginationEllipsisElement, MvxPaginationEllipsisEvents> = /*@__PURE__*/ createComponent<MvxPaginationEllipsisElement, MvxPaginationEllipsisEvents>({
    tagName: 'mvx-pagination-ellipsis',
    elementClass: MvxPaginationEllipsisElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxPaginationEllipsisEvents,
    defineCustomElement: defineMvxPaginationEllipsis
});

type MvxPaginationEllipsisFormEvents = { onSearch: EventName<CustomEvent<number>> };

export const MvxPaginationEllipsisForm: StencilReactComponent<MvxPaginationEllipsisFormElement, MvxPaginationEllipsisFormEvents> = /*@__PURE__*/ createComponent<MvxPaginationEllipsisFormElement, MvxPaginationEllipsisFormEvents>({
    tagName: 'mvx-pagination-ellipsis-form',
    elementClass: MvxPaginationEllipsisFormElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: { onSearch: 'search' } as MvxPaginationEllipsisFormEvents,
    defineCustomElement: defineMvxPaginationEllipsisForm
});

type MvxPasskeyProviderIconEvents = NonNullable<unknown>;

export const MvxPasskeyProviderIcon: StencilReactComponent<MvxPasskeyProviderIconElement, MvxPasskeyProviderIconEvents> = /*@__PURE__*/ createComponent<MvxPasskeyProviderIconElement, MvxPasskeyProviderIconEvents>({
    tagName: 'mvx-passkey-provider-icon',
    elementClass: MvxPasskeyProviderIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxPasskeyProviderIconEvents,
    defineCustomElement: defineMvxPasskeyProviderIcon
});

type MvxSidePanelEvents = {
    onClose: EventName<CustomEvent<any>>,
    onBack: EventName<CustomEvent<any>>
};

export const MvxSidePanel: StencilReactComponent<MvxSidePanelElement, MvxSidePanelEvents> = /*@__PURE__*/ createComponent<MvxSidePanelElement, MvxSidePanelEvents>({
    tagName: 'mvx-side-panel',
    elementClass: MvxSidePanelElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {
        onClose: 'close',
        onBack: 'back'
    } as MvxSidePanelEvents,
    defineCustomElement: defineMvxSidePanel
});

type MvxSpinnerIconEvents = NonNullable<unknown>;

export const MvxSpinnerIcon: StencilReactComponent<MvxSpinnerIconElement, MvxSpinnerIconEvents> = /*@__PURE__*/ createComponent<MvxSpinnerIconElement, MvxSpinnerIconEvents>({
    tagName: 'mvx-spinner-icon',
    elementClass: MvxSpinnerIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxSpinnerIconEvents,
    defineCustomElement: defineMvxSpinnerIcon
});

type MvxTooltipEvents = { onTriggerRender: EventName<CustomEvent<boolean>> };

export const MvxTooltip: StencilReactComponent<MvxTooltipElement, MvxTooltipEvents> = /*@__PURE__*/ createComponent<MvxTooltipElement, MvxTooltipEvents>({
    tagName: 'mvx-tooltip',
    elementClass: MvxTooltipElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: { onTriggerRender: 'triggerRender' } as MvxTooltipEvents,
    defineCustomElement: defineMvxTooltip
});

type MvxTransactionAccountEvents = NonNullable<unknown>;

export const MvxTransactionAccount: StencilReactComponent<MvxTransactionAccountElement, MvxTransactionAccountEvents> = /*@__PURE__*/ createComponent<MvxTransactionAccountElement, MvxTransactionAccountEvents>({
    tagName: 'mvx-transaction-account',
    elementClass: MvxTransactionAccountElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTransactionAccountEvents,
    defineCustomElement: defineMvxTransactionAccount
});

type MvxTransactionAccountNameEvents = NonNullable<unknown>;

export const MvxTransactionAccountName: StencilReactComponent<MvxTransactionAccountNameElement, MvxTransactionAccountNameEvents> = /*@__PURE__*/ createComponent<MvxTransactionAccountNameElement, MvxTransactionAccountNameEvents>({
    tagName: 'mvx-transaction-account-name',
    elementClass: MvxTransactionAccountNameElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTransactionAccountNameEvents,
    defineCustomElement: defineMvxTransactionAccountName
});

type MvxTransactionAgeEvents = NonNullable<unknown>;

export const MvxTransactionAge: StencilReactComponent<MvxTransactionAgeElement, MvxTransactionAgeEvents> = /*@__PURE__*/ createComponent<MvxTransactionAgeElement, MvxTransactionAgeEvents>({
    tagName: 'mvx-transaction-age',
    elementClass: MvxTransactionAgeElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTransactionAgeEvents,
    defineCustomElement: defineMvxTransactionAge
});

type MvxTransactionDirectionBadgeEvents = NonNullable<unknown>;

export const MvxTransactionDirectionBadge: StencilReactComponent<MvxTransactionDirectionBadgeElement, MvxTransactionDirectionBadgeEvents> = /*@__PURE__*/ createComponent<MvxTransactionDirectionBadgeElement, MvxTransactionDirectionBadgeEvents>({
    tagName: 'mvx-transaction-direction-badge',
    elementClass: MvxTransactionDirectionBadgeElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTransactionDirectionBadgeEvents,
    defineCustomElement: defineMvxTransactionDirectionBadge
});

type MvxTransactionHashEvents = NonNullable<unknown>;

export const MvxTransactionHash: StencilReactComponent<MvxTransactionHashElement, MvxTransactionHashEvents> = /*@__PURE__*/ createComponent<MvxTransactionHashElement, MvxTransactionHashEvents>({
    tagName: 'mvx-transaction-hash',
    elementClass: MvxTransactionHashElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTransactionHashEvents,
    defineCustomElement: defineMvxTransactionHash
});

type MvxTransactionIconEvents = NonNullable<unknown>;

export const MvxTransactionIcon: StencilReactComponent<MvxTransactionIconElement, MvxTransactionIconEvents> = /*@__PURE__*/ createComponent<MvxTransactionIconElement, MvxTransactionIconEvents>({
    tagName: 'mvx-transaction-icon',
    elementClass: MvxTransactionIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTransactionIconEvents,
    defineCustomElement: defineMvxTransactionIcon
});

type MvxTransactionListItemEvents = NonNullable<unknown>;

export const MvxTransactionListItem: StencilReactComponent<MvxTransactionListItemElement, MvxTransactionListItemEvents> = /*@__PURE__*/ createComponent<MvxTransactionListItemElement, MvxTransactionListItemEvents>({
    tagName: 'mvx-transaction-list-item',
    elementClass: MvxTransactionListItemElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTransactionListItemEvents,
    defineCustomElement: defineMvxTransactionListItem
});

type MvxTransactionMethodEvents = NonNullable<unknown>;

export const MvxTransactionMethod: StencilReactComponent<MvxTransactionMethodElement, MvxTransactionMethodEvents> = /*@__PURE__*/ createComponent<MvxTransactionMethodElement, MvxTransactionMethodEvents>({
    tagName: 'mvx-transaction-method',
    elementClass: MvxTransactionMethodElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTransactionMethodEvents,
    defineCustomElement: defineMvxTransactionMethod
});

type MvxTransactionShardsEvents = NonNullable<unknown>;

export const MvxTransactionShards: StencilReactComponent<MvxTransactionShardsElement, MvxTransactionShardsEvents> = /*@__PURE__*/ createComponent<MvxTransactionShardsElement, MvxTransactionShardsEvents>({
    tagName: 'mvx-transaction-shards',
    elementClass: MvxTransactionShardsElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTransactionShardsEvents,
    defineCustomElement: defineMvxTransactionShards
});

type MvxTransactionValueEvents = NonNullable<unknown>;

export const MvxTransactionValue: StencilReactComponent<MvxTransactionValueElement, MvxTransactionValueEvents> = /*@__PURE__*/ createComponent<MvxTransactionValueElement, MvxTransactionValueEvents>({
    tagName: 'mvx-transaction-value',
    elementClass: MvxTransactionValueElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTransactionValueEvents,
    defineCustomElement: defineMvxTransactionValue
});

type MvxTransactionsTableEvents = NonNullable<unknown>;

export const MvxTransactionsTable: StencilReactComponent<MvxTransactionsTableElement, MvxTransactionsTableEvents> = /*@__PURE__*/ createComponent<MvxTransactionsTableElement, MvxTransactionsTableEvents>({
    tagName: 'mvx-transactions-table',
    elementClass: MvxTransactionsTableElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTransactionsTableEvents,
    defineCustomElement: defineMvxTransactionsTable
});

type MvxTriangularWarningIconEvents = NonNullable<unknown>;

export const MvxTriangularWarningIcon: StencilReactComponent<MvxTriangularWarningIconElement, MvxTriangularWarningIconEvents> = /*@__PURE__*/ createComponent<MvxTriangularWarningIconElement, MvxTriangularWarningIconEvents>({
    tagName: 'mvx-triangular-warning-icon',
    elementClass: MvxTriangularWarningIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTriangularWarningIconEvents,
    defineCustomElement: defineMvxTriangularWarningIcon
});

type MvxTrimTextEvents = NonNullable<unknown>;

export const MvxTrimText: StencilReactComponent<MvxTrimTextElement, MvxTrimTextEvents> = /*@__PURE__*/ createComponent<MvxTrimTextElement, MvxTrimTextEvents>({
    tagName: 'mvx-trim-text',
    elementClass: MvxTrimTextElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxTrimTextEvents,
    defineCustomElement: defineMvxTrimText
});

type MvxUnlockButtonEvents = NonNullable<unknown>;

export const MvxUnlockButton: StencilReactComponent<MvxUnlockButtonElement, MvxUnlockButtonEvents> = /*@__PURE__*/ createComponent<MvxUnlockButtonElement, MvxUnlockButtonEvents>({
    tagName: 'mvx-unlock-button',
    elementClass: MvxUnlockButtonElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxUnlockButtonEvents,
    defineCustomElement: defineMvxUnlockButton
});

type MvxUnlockProviderButtonEvents = NonNullable<unknown>;

export const MvxUnlockProviderButton: StencilReactComponent<MvxUnlockProviderButtonElement, MvxUnlockProviderButtonEvents> = /*@__PURE__*/ createComponent<MvxUnlockProviderButtonElement, MvxUnlockProviderButtonEvents>({
    tagName: 'mvx-unlock-provider-button',
    elementClass: MvxUnlockProviderButtonElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxUnlockProviderButtonEvents,
    defineCustomElement: defineMvxUnlockProviderButton
});

type MvxUnlockProviderIntroEvents = { onAccess: EventName<CustomEvent<any>> };

export const MvxUnlockProviderIntro: StencilReactComponent<MvxUnlockProviderIntroElement, MvxUnlockProviderIntroEvents> = /*@__PURE__*/ createComponent<MvxUnlockProviderIntroElement, MvxUnlockProviderIntroEvents>({
    tagName: 'mvx-unlock-provider-intro',
    elementClass: MvxUnlockProviderIntroElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: { onAccess: 'access' } as MvxUnlockProviderIntroEvents,
    defineCustomElement: defineMvxUnlockProviderIntro
});

type MvxWalletConnectFlowEvents = NonNullable<unknown>;

export const MvxWalletConnectFlow: StencilReactComponent<MvxWalletConnectFlowElement, MvxWalletConnectFlowEvents> = /*@__PURE__*/ createComponent<MvxWalletConnectFlowElement, MvxWalletConnectFlowEvents>({
    tagName: 'mvx-wallet-connect-flow',
    elementClass: MvxWalletConnectFlowElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxWalletConnectFlowEvents,
    defineCustomElement: defineMvxWalletConnectFlow
});

type MvxWalletProviderIconEvents = NonNullable<unknown>;

export const MvxWalletProviderIcon: StencilReactComponent<MvxWalletProviderIconElement, MvxWalletProviderIconEvents> = /*@__PURE__*/ createComponent<MvxWalletProviderIconElement, MvxWalletProviderIconEvents>({
    tagName: 'mvx-wallet-provider-icon',
    elementClass: MvxWalletProviderIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxWalletProviderIconEvents,
    defineCustomElement: defineMvxWalletProviderIcon
});

type MvxXaliasProviderIconEvents = NonNullable<unknown>;

export const MvxXaliasProviderIcon: StencilReactComponent<MvxXaliasProviderIconElement, MvxXaliasProviderIconEvents> = /*@__PURE__*/ createComponent<MvxXaliasProviderIconElement, MvxXaliasProviderIconEvents>({
    tagName: 'mvx-xalias-provider-icon',
    elementClass: MvxXaliasProviderIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxXaliasProviderIconEvents,
    defineCustomElement: defineMvxXaliasProviderIcon
});

type MvxXportalDownloadQrIconEvents = NonNullable<unknown>;

export const MvxXportalDownloadQrIcon: StencilReactComponent<MvxXportalDownloadQrIconElement, MvxXportalDownloadQrIconEvents> = /*@__PURE__*/ createComponent<MvxXportalDownloadQrIconElement, MvxXportalDownloadQrIconEvents>({
    tagName: 'mvx-xportal-download-qr-icon',
    elementClass: MvxXportalDownloadQrIconElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxXportalDownloadQrIconEvents,
    defineCustomElement: defineMvxXportalDownloadQrIcon
});

type MvxXportalQrCodePreloaderEvents = NonNullable<unknown>;

export const MvxXportalQrCodePreloader: StencilReactComponent<MvxXportalQrCodePreloaderElement, MvxXportalQrCodePreloaderEvents> = /*@__PURE__*/ createComponent<MvxXportalQrCodePreloaderElement, MvxXportalQrCodePreloaderEvents>({
    tagName: 'mvx-xportal-qr-code-preloader',
    elementClass: MvxXportalQrCodePreloaderElement,
    // @ts-ignore - React type of Stencil Output Target may differ from the React version used in the Nuxt.js project, this can be ignored.
    react: React,
    events: {} as MvxXportalQrCodePreloaderEvents,
    defineCustomElement: defineMvxXportalQrCodePreloader
});
