declare module '@evan.network/ui-vue-core'
{
	import Vue from 'vue';
	import VueRouter from 'vue-router';
	import vuexI18n from 'vuex-i18n';
	export default class EvanComponent extends Vue {
	    /**
	     * active dapp that was detected by the routing lib (getNextDApp)
	     */
	    dapp: any;
	    /**
	     * Active dapp browser domain name
	     */
	    domainName: string;
	    /**
	     * Declare vue stuff
	     */
	    $i18n: vuexI18n;
	    $router: VueRouter;
	    $store: any;
	    $t: any;
	    constructor();
	    /**
	     * Specify a custom navigation method for evan vue projects.
	     */
	    evanNavigate(path: string): void;
	    /**
	     * Returns the active dapp object, including the current contract address, route base hash and
	     * ens address
	     *
	     * @return     {any}  routing.getNextDApp result
	     */
	    activeDApp(): any;
	    /**
	     * Returns the current runtime from the state or returns an dappBrowser core runtime.
	     *
	     * @return     {any}  bcc runtime
	     */
	    getRuntime(): any;
	}

	import Vue from 'vue';
	import { EvanFormControlOptions } from './interfaces';
	/**
	 * One input control representation.
	 *
	 * @class      EvanFormControl (name)
	 */
	export class EvanFormControl {
	    /**
	     * Is the current element dirty? Error will be only returned, if an error is available.
	     */
	    dirty: boolean;
	    /**
	     * Internal error without custom getter
	     */
	    _error: any;
	    /**
	     * overwrite the error getter, so we only return an error, when the element is dirty
	     */
	    error: any;
	    /**
	     * Form control name.
	     */
	    name: string;
	    /**
	     * form control reference
	     */
	    readonly $ref: any;
	    /**
	     * Original value, without custom setter amd getter
	     */
	    _value: any;
	    /**
	     * overwrite the value getter, so we automatically check for errors, when an validate was
	     * applied.
	     */
	    value: any;
	    /**
	     * validate function that will be runned when the value was changed
	     */
	    _validate: Function | undefined;
	    /**
	     * The vue instance of for validation etc..
	     */
	    vueInstance: Vue;
	    /**
	     * Parent evan form, so the form is valid flag can be set automatically
	     */
	    form: EvanForm | undefined;
	    /**
	     * True, when an asynchronious validate function was applied and this validation is running
	     */
	    validating: boolean;
	    /**
	     * Create the new forms instance.
	     */
	    constructor(name: string, value: any, vueInstance: Vue, validate?: Function, form?: EvanForm);
	    /**
	     * Sets the control into dirty mode.
	     */
	    setDirty(): void;
	    /**
	     * Runs the validate function for this control
	     */
	    validate(): Promise<void>;
	}
	/**
	 * Generalized data representation for a formular.
	 *
	 * @class      EvanForm
	 */
	export class EvanForm {
	    /**
	     * list of control names that were applied to the form
	     */
	    controls: Array<string>;
	    /**
	     * The vue instance of for validation etc..
	     */
	    vueInstance: Vue;
	    /**
	     * Is everything valid within the form?
	     */
	    isValid: boolean;
	    /**
	     * Checks for an valid email address.
	     *
	     * @param      {string}   email   email address to checkl
	     * @return     {boolean}  true / false
	     */
	    static validateEmail(email: string): boolean;
	    /**
	     * Checks for an valid ethereum accoung id.
	     *
	     * @param      {string}   email   email address to checkl
	     * @return     {boolean}  true / false
	     */
	    static validEthAddress(address: string): boolean;
	    constructor(vueInstance: any, controls: {
	        [s: string]: EvanFormControlOptions;
	    });
	    /**
	     * Check all controls if they are valid.
	     */
	    validateControls(): void;
	}

	export * from './components/registry';
	export * from './forms';
	export * from './interfaces';
	export * from './routing';
	export * from './vue-core';

	/******************************************** interfaces ******************************************/
	/**
	 * Used to map routes to a route name and a specific component.
	 */
	export interface RouteRegistrationInterface {
	    path: string;
	    name?: string;
	    component?: any;
	    children?: any;
	    redirect?: any;
	}
	/**
	 * Used to map routes path including icon and title for dapp-wrapper sidebar
	 */
	export interface DAppWrapperRouteInterface {
	    fullPath?: string;
	    icon: string;
	    path: string;
	    title: string;
	}
	/**
	 * Used to map components to it's template names. (ref.: ./components/registry)
	 */
	export interface ComponentRegistrationInterface {
	    name: string;
	    component: any;
	}
	/**
	 * Used to initialize the evan vue core to startup a whole new vue instance including routes, i18n,
	 * components, vuex, ...
	 */
	export interface EvanVueOptionsInterface {
	    components: Array<ComponentRegistrationInterface>;
	    container: Element;
	    dappBaseUrl: string;
	    dappEnsOrContract: string;
	    dbcpName: string;
	    RootComponent: any;
	    routes: Array<RouteRegistrationInterface>;
	    state: any;
	    translations: any;
	    Vue: any;
	}
	/**
	 * Represents one generalized form control within an vue form.
	 */
	export interface EvanFormControlOptions {
	    validate?: Function;
	    name: string;
	    value?: any;
	}

	import VueRouter from 'vue-router';
	import { EvanVueOptionsInterface } from './interfaces';
	/**
	 * Start the routing for a vue application. Clones the original routes and sets the base routing (=
	 * current dapp that should be opened).
	 *
	 * @param      {EvanVueOptionsInterface}  options  Evan vue options
	 */
	export function initializeRouting(options: EvanVueOptionsInterface): Promise<{
	    dappToLoad: {
	        baseHash: any;
	        contractAddress: any;
	        domainName: any;
	        ens: string;
	        fullUrl: string;
	    };
	    router: VueRouter;
	}>;
	/**
	 * Retrieves the url hash path for the next dapp, that should be loaded, by checking the
	 * dappEnsOrContract address or by tracing every url hash part and checks, if an element with the
	 * dom id exists.
	 *
	 * Returns ens:
	 *   - ens: ens address of the loaded dapp
	 *   - contractAddess: optional detected contract address
	 *   - baseHash: base of the dapp
	 *
	 * E.g.: opened url #/dashboard.evan/onboarding.evan
	 *
	 *   1. dashboard.evan element was not found, start it
	 *   2. dashboard.evan/** will be triggered and loads the dapp-loader compoment
	 *   3. dapp-loader tracks the url hashes and detects the dashboard.evan/onboarding.evan route and
	 *      will start this dapp in the dapp-loader
	 *   4. when navigating to /dashboard.evan/identities.evan, the dapp-loader trackts the url change
	 *      and 3. will be started with the new url hash
	 *
	 * @param      {string}  dappEnsOrContract  The dapp ens or contract (e.g.
	 *                                          /dashboard.evan/onboarding.evan)
	 */
	export function getNextDApp(dappEnsOrContract?: string): Promise<{
	    baseHash: any;
	    contractAddress: any;
	    domainName: any;
	    ens: string;
	    fullUrl: string;
	}>;

	import { ComponentRegistrationInterface, EvanVueOptionsInterface } from './interfaces';
	/******************************************** functions *******************************************/
	/**
	 * Stats an evan vue dapp and wraps all start functinalities.
	 *
	 * @param      {EvanVueOptions}  options  vue options passed by the dapp
	 */
	export function initializeVue(options: EvanVueOptionsInterface): Promise<any>;
	/**
	 * Registers the components within Vue. If a name is specified, register it also as component, not
	 * only for routing.
	 *
	 * @param      {any}     Vue     vue prototype
	 */
	export function registerComponents(Vue: any, components: Array<ComponentRegistrationInterface>): void;
	/**
	 * Register the current translations within vueJS.
	 *
	 * @param      {any}  Vue           vue prototype
	 * @param      {any}  translations  key value object of languages ({ 'de': { ... } })
	 */
	export function registerEvanI18N(Vue: any, translations: any): void;

	import { ComponentRegistrationInterface } from '../interfaces';
	import Breadcrumbs from './breadcrumbs/breadcrumbs.vue';
	import DAppLoader from './dapp-loader/dapp-loader.vue';
	import DAppLoading from './loading/loading.vue';
	import DAppWrapper from './dapp-wrapper/dapp-wrapper.vue';
	import DAppWrapperSidebarLevel2 from './dapp-wrapper-level-2/dapp-wrapper-level-2.vue';
	import Dropdown from './dropdown/dropdown.vue';
	import EvanComponent from '../component';
	import EvanIframe from './iframe/iframe.vue';
	import Login from './login/login.vue';
	import Logout from './logout/logout.vue';
	import Modal from './modal/modal.vue';
	import Success from './success/success.vue';
	export { Breadcrumbs, DAppLoader, DAppLoading, DAppWrapper, DAppWrapperSidebarLevel2, Dropdown, EvanComponent, EvanIframe, Login, Logout, Modal, Success, };
	const componentRegistration: Array<ComponentRegistrationInterface>;
	export default componentRegistration;

	import EvanComponent from '../../component';
	const Breadcrumbs_base: import("../../../../../node_modules/vue-class-component/lib/declarations").VueClass<EvanComponent>;
	export default class Breadcrumbs extends Breadcrumbs_base {
	    i18nScope: any;
	    enableReload: any;
	    breadcrumbs: any[];
	    /**
	     * Watch for hash updates
	     */
	    hashChangeWatcher: any;
	    /**
	     * Was the component destroyed, before the hash change event was bind?
	     */
	    wasDestroyed: boolean;
	    /**
	     * Show the go back button
	     */
	    goBack: boolean;
	    /**
	     * Bind the hash change watcher to track hash changes and to update the routes
	     */
	    created(): Promise<void>;
	    /**
	     * Clear the hash change watcher
	     */
	    beforeDestroy(): void;
	}
	export {};

	import EvanComponent from '../../component';
	const DAppLoader_base: import("../../../../../node_modules/vue-class-component/lib/declarations").VueClass<EvanComponent>;
	export default class DAppLoader extends DAppLoader_base {
	    /**
	     * save the latest dapp path that was started, so we can check on an hash change, if the dapp for
	     * this dapp loader has been changed.
	     */
	    startedDApp: any;
	    /**
	     * Watch for hash updates and start a new dapp, when the corresponding hash for this dapp-loader
	     * has been changed
	     */
	    hashChangeWatcher: any;
	    /**
	     * no valid dapp could be found for this route
	     */
	    dappNotFound: boolean;
	    /**
	     * Was the component destroyed, before the hash change event was bind?
	     */
	    wasDestroyed: boolean;
	    /**
	     * Start the dapp directly and create an hash change watcher, so we can react on hash changes to
	     * reload the dapp or to start another one.
	     */
	    mounted(): Promise<void>;
	    /**
	     * Clear the hash change watcher
	     */
	    beforeDestroy(): void;
	    /**
	     * Searches for the next dapp in the url that should be started and run it
	     */
	    startDApp(): Promise<void>;
	}
	export {};

	import EvanComponent from '../../component';
	import { DAppWrapperRouteInterface } from '../../interfaces';
	const DAppWrapper_base: import("../../../../../node_modules/vue-class-component/lib/declarations").VueClass<EvanComponent>;
	export default class DAppWrapper extends DAppWrapper_base {
	    /**
	     * url to img for large sidebar (default is set in the create function using $store)
	     */
	    brandLarge: string;
	    /**
	     * url to img for large sidebar (default is set in the create function using $store)
	     */
	    brandSmall: string;
	    /**
	     * routes that should be displayed in the sidepanel, if no sidebar slot is given
	     * format: [
	     *    {
	     *      name: 'favorites.evan',
	     *      icon: 'fas fa-bookmark',
	     *      title: '_dashboard.routes.favorites'
	     *    }
	     *  ]
	     */
	    routes: Array<DAppWrapperRouteInterface>;
	    /**
	     * organized like the normal routes, but displayed smaller on the bottom of the nav
	     */
	    bottomRoutes: Array<DAppWrapperRouteInterface>;
	    /**
	     * base url of the vue component that uses the dapp-wrapper (e.g.: dashboard.evan)
	     */
	    routeBaseHash: string;
	    /**
	     * should be the runtime created? Includes onboarding & login checks.
	     */
	    createRuntime: any;
	    /**
	     * is the current dapp-wrapper gets initialized? => use loading to don't render dapp-loader or
	     * something quickly and directly after this remove the content and show the login or onboarding
	     */
	    loading: boolean;
	    /**
	     * is the small toolbar shown on large devices?
	     */
	    smallToolbar: boolean;
	    /**
	     * Is the sidebar enabled and should be shown? Per defaul enabled, but when no routes are defined
	     * or the user is within an onboarding or login process, it will be true.
	     */
	    enableSidebar: boolean;
	    /**
	     * Enables the nav bar icons including mailbox, synchronisation, .... Will be disabled uring login
	     * or onboarding process.
	     */
	    enableNav: boolean;
	    /**
	     * show sidebar on small / medium devices?
	     */
	    showSideBar: boolean;
	    /**
	     * show second level navigation on small devices?
	     */
	    showSideBar2: boolean;
	    /**
	     * login function that was applied by the setPasswordFunction
	     */
	    login: Function | boolean;
	    /**
	     * onboarding dapp is opened, so the user isn't logged in
	     */
	    onboarding: Function | boolean;
	    /**
	     * Watch for hash updates when the user is on the onboarding screen. Wait for the user to finished
	     * the process.
	     */
	    hashChangeWatcher: any;
	    /**
	     * current user informations
	     */
	    userInfo: any;
	    /**
	     * Queue loading informations
	     */
	    queueInstances: {};
	    queueCount: number;
	    queueLoading: boolean;
	    queueWatcher: any;
	    /**
	     * Show a modal for delete / accepting an dispatcher instance
	     */
	    instanceInteraction: any;
	    /**
	     * Set interval to reload mails each 30 seconds
	     */
	    mailsWatcher: any;
	    /**
	     * Core routes that will be displayed in the top right user dropdown
	     */
	    coreRoutes: {
	        title: string;
	        path: string;
	        icon: string;
	    }[];
	    /**
	     * Returns the i18n title key for the active route.
	     *
	     * @return     {string}  active route i18n or route path
	     */
	    readonly activeRouteTitle: string;
	    /**
	     * Toggles the toolbar large and small on big screens, on medium screens show hide the toolbar, on
	     * small screens, show / hide both toolbars.
	     */
	    toggleSmallToolbar(): void;
	    /**
	     * Triggered when the a root sidebar navigation was clicked. If the route already activated, show
	     * the second level navigation.
	     *
	     * @param      {DAppWrapperRouteInterface}  route   route that was activated
	     */
	    routeActivated(route: DAppWrapperRouteInterface): void;
	    /**
	     * Initialize the core runtime for the evan network.
	     */
	    created(): Promise<any>;
	    /**
	     * Clear the hash change watcher
	     */
	    beforeDestroy(): void;
	    /**
	     * Check for parent dapp-wrapper elements and disable nav / sidebar if needed
	     */
	    mounted(): Promise<void>;
	    /**
	     * If a runtime should be created, ensure that the user is logged in / onboarded and create
	     * runtimes
	     */
	    handleLoginOnboarding(): Promise<void>;
	    /**
	     * Navigates the user to the root page of the dapp.
	     */
	    openRouteBaseHash(): void;
	    /**
	     * Load the users specific data.
	     */
	    loadUserSpecific(): Promise<void>;
	    /**
	     * Load the mail informations for the current user
	     */
	    loadMails(mailsToReach?: number): Promise<void>;
	    /**
	     * Opens the mail preview dropdown and sets the evan-mail-read-count.
	     */
	    openMailDropdown(): void;
	    /**
	     * Opens a mail within the mailbox
	     */
	    openMail(mail: any, $event: any): void;
	    /**
	     * Load the queue data
	     */
	    setupQueue(): Promise<void>;
	    /**
	     * Starts an dispatcher instances and checks for accept status.
	     *
	     * @param      {any}  instance  an dispatcher instance
	     */
	    startDispatcherInstance(instance: any): void;
	}
	export {};

	import EvanComponent from '../../component';
	const DAppWrapperLevel2_base: import("../../../../../node_modules/vue-class-component/lib/declarations").VueClass<EvanComponent>;
	export default class DAppWrapperLevel2 extends DAppWrapperLevel2_base {
	    /**
	     * found dapp-wrapper-sidebar 2 container element, where this element can be applied to
	     */
	    highestSidebar: Element;
	    /**
	     * Child element that contains the level 2 content
	     */
	    contentElement: Element;
	    /**
	     * Watch for dom removal of the parent element of the dapp-wrapper level 2, so we can destroy this
	     * one
	     */
	    elementObserver: any;
	    /**
	     * Run destoyed method only ones
	     */
	    isDestroyed: boolean;
	    /**
	     * Take the current element and search for an parent wrapper level 2 container, so move the
	     * current element to this element.
	     */
	    mounted(): void;
	    /**
	     * Trigger destroy function
	     */
	    beforeDestroy(): void;
	    /**
	     * When the element was destroyed, remove this element from the parent dapp-wrapper-2 container,
	     * when found.
	     */
	    destroy(): void;
	}
	export {};

	import EvanComponent from '../../component';
	const Dropdown_base: import("../../../../../node_modules/vue-class-component/lib/declarations").VueClass<EvanComponent>;
	export default class Dropdown extends Dropdown_base {
	    alignment: string;
	    width: string;
	    /**
	     * shows the dom elements of the modal
	     */
	    isRendered: boolean;
	    /**
	     * animate them
	     */
	    isShown: boolean;
	    /**
	     * Renders the modal element and shows it animated.
	     */
	    show(): void;
	    /**
	     * Remove the modal element and hide it animated.
	     */
	    hide($event: any): void;
	}
	export {};

	import EvanComponent from '../../component';
	const EvanIframe_base: import("../../../../../node_modules/vue-class-component/lib/declarations").VueClass<EvanComponent>;
	export default class EvanIframe extends EvanIframe_base {
	    src: any;
	    /**
	     * show loading indicator
	     */
	    loading: boolean;
	    created(): void;
	}
	export {};

	import EvanComponent from '../../component';
	const DAppLoading_base: import("../../../../../node_modules/vue-class-component/lib/declarations").VueClass<EvanComponent>;
	export default class DAppLoading extends DAppLoading_base {
	}
	export {};

	import EvanComponent from '../../component';
	const LoginComponent_base: import("../../../../../node_modules/vue-class-component/lib/declarations").VueClass<EvanComponent>;
	export default class LoginComponent extends LoginComponent_base {
	    /**
	     * preload accountId
	     */
	    accountId: any;
	    checkingPassword: boolean;
	    /**
	     * formular specific variables
	     */
	    form: {
	        /**
	         * current password input
	         */
	        password: {
	            value: any;
	            valid: boolean;
	            dirty: boolean;
	            ref: any;
	        };
	    };
	    /**
	     * Focus the password element.
	     */
	    mounted(): void;
	    /**
	     * Check the current password input and send the logged in event to the parent component.
	     *
	     * @param      {any}  event   form submit event
	     */
	    login(): Promise<void>;
	}
	export {};

	import EvanComponent from '../../component';
	const EvanLogoutComponent_base: import("../../../../../node_modules/vue-class-component/lib/declarations").VueClass<EvanComponent>;
	export default class EvanLogoutComponent extends EvanLogoutComponent_base {
	    /**
	     * Dont show any button
	     */
	    disableButton: any;
	    /**
	     * Show the logout modal
	     */
	    logout(): void;
	    /**
	     * Logout the user.
	     */
	    runLogout(): void;
	}
	export {};

	import EvanComponent from '../../component';
	const ModalComponent_base: import("../../../../../node_modules/vue-class-component/lib/declarations").VueClass<EvanComponent>;
	export default class ModalComponent extends ModalComponent_base {
	    /**
	     * shows the dom elements of the modal
	     */
	    isRendered: boolean;
	    /**
	     * animate them
	     */
	    isShown: boolean;
	    /**
	     * Renders the modal element and shows it animated.
	     */
	    show(): void;
	    /**
	     * Remove the modal element and hide it animated.
	     */
	    hide(): void;
	}
	export {};

	import EvanComponent from '../../component';
	const SuccessComponent_base: import("../../../../../node_modules/vue-class-component/lib/declarations").VueClass<EvanComponent>;
	export default class SuccessComponent extends SuccessComponent_base {
	}
	export {};

	const _default: {
	    "_evan": {
	        "_routes": {
	            "contacts": string;
	            "favorites": string;
	            "identities": string;
	            "mailbox": string;
	            "profile": string;
	        };
	        "cancel": string;
	        "dapp-wrapper": {
	            "all-messages": string;
	            "empty-queue": string;
	            "instance-delete": {
	                "ok": string;
	                "desc": string;
	                "title": string;
	            };
	            "instance-accept": {
	                "ok": string;
	                "desc": string;
	                "title": string;
	            };
	            "my-contacts": string;
	            "my-mailbox": string;
	            "my-profile": string;
	            "new-mails": string;
	            "queue": string;
	            "queue-continue": string;
	            "queue-error": string;
	        };
	        "invalid-password": string;
	        "login": string;
	        "logout": string;
	        "logout-desc": string;
	        "password": string;
	        "password-placeholder": string;
	        "please-login": string;
	        "use-password": string;
	        "welcome-to-evan": string;
	    };
	};
	export default _default;

	const _default: {
	    "_evan": {
	        "_routes": {
	            "contacts": string;
	            "favorites": string;
	            "identities": string;
	            "mailbox": string;
	            "profile": string;
	        };
	        "cancel": string;
	        "dapp-wrapper": {
	            "all-messages": string;
	            "empty-queue": string;
	            "instance-delete": {
	                "ok": string;
	                "desc": string;
	                "title": string;
	            };
	            "instance-accept": {
	                "ok": string;
	                "desc": string;
	                "title": string;
	            };
	            "my-contacts": string;
	            "my-mailbox": string;
	            "my-profile": string;
	            "new-mails": string;
	            "queue": string;
	            "queue-continue": string;
	            "queue-error": string;
	        };
	        "invalid-password": string;
	        "login": string;
	        "logout": string;
	        "logout-desc": string;
	        "password": string;
	        "password-placeholder": string;
	        "please-login": string;
	        "use-password": string;
	        "welcome-to-evan": string;
	    };
	};
	export default _default;

	const _default: {
	    de: {
	        "_evan": {
	            "_routes": {
	                "contacts": string;
	                "favorites": string;
	                "identities": string;
	                "mailbox": string;
	                "profile": string;
	            };
	            "cancel": string;
	            "dapp-wrapper": {
	                "all-messages": string;
	                "empty-queue": string;
	                "instance-delete": {
	                    "ok": string;
	                    "desc": string;
	                    "title": string;
	                };
	                "instance-accept": {
	                    "ok": string;
	                    "desc": string;
	                    "title": string;
	                };
	                "my-contacts": string;
	                "my-mailbox": string;
	                "my-profile": string;
	                "new-mails": string;
	                "queue": string;
	                "queue-continue": string;
	                "queue-error": string;
	            };
	            "invalid-password": string;
	            "login": string;
	            "logout": string;
	            "logout-desc": string;
	            "password": string;
	            "password-placeholder": string;
	            "please-login": string;
	            "use-password": string;
	            "welcome-to-evan": string;
	        };
	    };
	    en: {
	        "_evan": {
	            "_routes": {
	                "contacts": string;
	                "favorites": string;
	                "identities": string;
	                "mailbox": string;
	                "profile": string;
	            };
	            "cancel": string;
	            "dapp-wrapper": {
	                "all-messages": string;
	                "empty-queue": string;
	                "instance-delete": {
	                    "ok": string;
	                    "desc": string;
	                    "title": string;
	                };
	                "instance-accept": {
	                    "ok": string;
	                    "desc": string;
	                    "title": string;
	                };
	                "my-contacts": string;
	                "my-mailbox": string;
	                "my-profile": string;
	                "new-mails": string;
	                "queue": string;
	                "queue-continue": string;
	                "queue-error": string;
	            };
	            "invalid-password": string;
	            "login": string;
	            "logout": string;
	            "logout-desc": string;
	            "password": string;
	            "password-placeholder": string;
	            "please-login": string;
	            "use-password": string;
	            "welcome-to-evan": string;
	        };
	    };
	};
	export default _default;

	import DAppLoader from './dapp-loader.ts';
	export default DAppLoader;

	import Component from './breadcrumbs.ts';
	export default Component;

	import DAppLoading from './loading.ts';
	export default DAppLoading;

	import DAppWrapperLevel2 from './dapp-wrapper-level-2.ts';
	export default DAppWrapperLevel2;

	import Component from './dropdown.ts';
	export default Component;

	import EvanIframe from './iframe.ts';
	export default EvanIframe;

	import LoginComponent from './login.ts';
	export default LoginComponent;

	import EvanLogoutComponent from './logout.ts';
	export default EvanLogoutComponent;

	import ModalComponent from './modal.ts';
	export default ModalComponent;

	import SuccessComponent from './success.ts';
	export default SuccessComponent;

	import DAppWrapper from './dapp-wrapper.ts';
	export default DAppWrapper;

}