/************
Processor: ts
************/

import * as __beyond_dep_ns_0 from '@beyond-js/kernel/core';
// anchor.ts
declare namespace ns_0 {
  export {};
}


// attributes.ts
declare namespace ns_1 {
  import Events = __beyond_dep_ns_0.Events;
  export class Attributes extends Events {
    #private;
    get values(): Map<string, string>;
    add(name: string, value: string): void;
    remove(name: string): void;
  }
  export const attributes: Attributes;
}


// instances\index.ts
declare namespace ns_2 {
  import BeyondWidget = ns_8.BeyondWidget;
  import NodeWidget = ns_3.NodeWidget;
  export const instances: {
    register(widget: BeyondWidget): NodeWidget;
    add(value: BeyondWidget): any;
    clear(): void;
    delete(value: BeyondWidget): boolean;
    forEach(callbackfn: (value: BeyondWidget, value2: BeyondWidget, set: Set<BeyondWidget>) => void, thisArg?: any): void;
    has(value: BeyondWidget): boolean;
    readonly size: number;
    entries(): IterableIterator<[BeyondWidget, BeyondWidget]>;
    keys(): IterableIterator<BeyondWidget>;
    values(): IterableIterator<BeyondWidget>;
    [Symbol.iterator](): IterableIterator<BeyondWidget>;
    readonly [Symbol.toStringTag]: string;
  };
}


// instances\node.ts
declare namespace ns_3 {
  import BeyondWidget = ns_8.BeyondWidget;
  export class NodeWidget {
    #private;
    get widget(): BeyondWidget;
    get parent(): BeyondWidget;
    get children(): Set<BeyondWidget>;
    constructor(widget: BeyondWidget, parent?: BeyondWidget);
  }
}


// prerendered\index.ts
declare namespace ns_4 {
  import IWidgetRendered = ns_9.IWidgetRendered;
  export const prerender: {
    readonly "__#65950@#ssr": IWidgetRendered[];
    readonly ssr: IWidgetRendered[];
    find(element: string, attrs: Map<string, string>): IWidgetRendered;
  };
}


// widget\attributes.ts
declare namespace ns_5 {
  /**
   * The global attributes specified in widgets.attributes that apply to all the widgets in the application
   */
  export class WidgetGlobalAttributes {
    #private;
    get holder(): HTMLSpanElement;
    initialise(holder: HTMLSpanElement): void;
    destroy(): void;
  }
}


// widget\checksum.ts
declare namespace ns_6 {
  export function _default(s: string): string | number;
}


// widget\csr.ts
declare namespace ns_7 {
  import Events = __beyond_dep_ns_0.Events;
  import BeyondWidget = ns_8.BeyondWidget;
  export interface IBeyondWidgetController {
    initialise: () => Promise<void>;
    attributeChanged: (name: string, old: string, value: string) => void;
    disconnect: () => void;
  }
  export class WidgetCSR extends Events {
    #private;
    get bundle(): any;
    get controller(): IBeyondWidgetController;
    get error(): string;
    get loading(): boolean;
    get loaded(): boolean;
    initialise(): void;
    constructor(widget: BeyondWidget);
    disconnect(): void;
    attributeChanged(name: string, old: string, value: string): void;
  }
}


// widget\index.ts
declare namespace ns_8 {
  import NodeWidget = ns_3.NodeWidget;
  import WidgetSR = ns_10.WidgetSR;
  import IBeyondWidgetController = ns_7.IBeyondWidgetController;
  import WidgetCSR = ns_7.WidgetCSR;
  import WidgetSSR = ns_11.WidgetSSR;
  import StylesManager = ns_13.StylesManager;
  export interface IWidgetSpecs {
    name: string;
    vspecifier: string;
    attrs?: string[];
    is?: string;
    layout?: string;
    route?: string;
    render: {
      multilanguage?: boolean;
      ssr: boolean;
      csr: boolean;
      sr: boolean;
    };
  }
  const Element: {
    new (): HTMLElement;
    prototype: HTMLElement;
  };
  export class BeyondWidget extends Element {
    #private;
    get specs(): IWidgetSpecs;
    get name(): string;
    get vspecifier(): string;
    get specifier(): string;
    get host(): string;
    get is(): string;
    get route(): string;
    get layout(): string;
    get holder(): HTMLSpanElement;
    get sr(): WidgetSR;
    get csr(): WidgetCSR;
    get controller(): IBeyondWidgetController;
    get ssr(): WidgetSSR;
    get styles(): StylesManager;
    get wnode(): NodeWidget;
    get wparent(): BeyondWidget;
    get wchildren(): BeyondWidget[];
    constructor(specs: IWidgetSpecs);
    connectedCallback(): void;
    disconnectedCallback(): void;
    attributeChangedCallback(name: string, old: string, value: string): void;
  }
  export {};
}


// widget\renderer.ts
declare namespace ns_9 {
  import BeyondWidget = ns_8.BeyondWidget;
  export interface IWidgetRendered {
    element: string;
    html?: string;
    css?: string;
    errors?: string[];
    warnings?: string[];
    store?: object;
    attributes?: [string, string][];
  }
  export class Renderer {
    #private;
    constructor(widget: BeyondWidget);
    render(sr: IWidgetRendered): Promise<string>;
  }
}


// widget\sr.ts
declare namespace ns_10 {
  import BeyondWidget = ns_8.BeyondWidget;
  import IWidgetRendered = ns_9.IWidgetRendered;
  export class WidgetSR {
    #private;
    get prerender(): IWidgetRendered;
    constructor(widget: BeyondWidget);
    initialise(): Promise<void>;
  }
}


// widget\ssr.ts
declare namespace ns_11 {
  import BeyondWidget = ns_8.BeyondWidget;
  import IWidgetRendered = ns_9.IWidgetRendered;
  export class WidgetSSR {
    #private;
    get prerender(): IWidgetRendered;
    constructor(widget: BeyondWidget);
    /**
     * Check if widget is already pre-rendered (index.html makes a page ssr fetch)
     */
    initialise(): Promise<void>;
  }
}


// widget\styles\global.ts
declare namespace ns_12 {
  import BeyondWidget = ns_8.BeyondWidget;
  import Events = __beyond_dep_ns_0.Events;
  export class GlobalCSS extends Events {
    #private;
    constructor(widget: BeyondWidget);
    get link(): string;
    update(): void;
  }
}


// widget\styles\index.ts
declare namespace ns_13 {
  import Events = __beyond_dep_ns_0.Events;
  import BeyondWidget = ns_8.BeyondWidget;
  export class StylesManager {
    #private;
    on: (event: string, listener: () => void) => Events;
    off: (event: string, listener: () => void) => Events;
    get version(): number;
    get resources(): Set<string>;
    get loaded(): boolean;
    get ready(): Promise<void>;
    onloaded: (event: Event | string) => boolean;
    update(links: string[]): void;
    constructor(widget: BeyondWidget);
    get initialised(): boolean;
    initialise(links: string[]): Promise<void>;
    destroy(): void;
  }
}


// widget\styles\link.ts
declare namespace ns_14 {
  export class _default {
    #private;
    get href(): string;
    get resource(): string;
    get version(): number;
    constructor(href: string);
  }
}


// widgets.ts
declare namespace ns_15 {
  import IWidgetSpecs = ns_8.IWidgetSpecs;
  import instances = ns_2.instances;
  import Attributes = ns_1.Attributes;
  class BeyondWidgets extends Map<string, IWidgetSpecs> {
    #private;
    get ssr(): boolean;
    constructor();
    setup(config: {
      ssr?: boolean;
    }): void;
    get instances(): typeof instances;
    get attributes(): Attributes;
    register(specs: IWidgetSpecs[]): void;
  }
  export const widgets: BeyondWidgets;
  export {};
}


export import attributes = ns_1.attributes;
export import NodeWidget = ns_3.NodeWidget;
export import prerender = ns_4.prerender;
export import IBeyondWidgetController = ns_7.IBeyondWidgetController;
export import WidgetCSR = ns_7.WidgetCSR;
export import IWidgetSpecs = ns_8.IWidgetSpecs;
export import BeyondWidget = ns_8.BeyondWidget;
export import GlobalCSS = ns_12.GlobalCSS;
export import StylesManager = ns_13.StylesManager;
export import widgets = ns_15.widgets;

export declare const hmr: {on: (event: string, listener: any) => void, off: (event: string, listener: any) => void };