declare const WaferServer_base: {
    new (...args: any[]): {
        [x: string]: any;
        /**
         * Tag name that this component will be rendered within
         *
         * @type {string}
         */
        readonly props: {
            [x: string]: import("../types").Prop;
        };
        _connectedOnce: boolean;
        _propNames: string[];
        _attrToProp: {
            [x: string]: string;
        };
        _props: {
            [x: string]: any;
        };
        _changing: boolean;
        _updatePromise: Promise<void> | null;
        _toUpdate: Map<string, any>;
        _firstUpdate: boolean;
        _newChanges: boolean;
        _removeUnreflectedAttributes: boolean;
        _initials: {
            [x: string]: any;
        };
        _setter(name: string): (value: any) => void;
        _getter(name: string): () => any;
        initialiseProps(): void;
        setupPropValues(): void;
        _setFromAttribute(name: string, value: string | null): void;
        _setFromProp(name: string, value: any): void;
        attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
        triggerUpdate(): Promise<void>;
        update(props?: string[] | null | undefined): void;
        changed(changed: Map<string, any>): void | string[] | Promise<string[]>;
        updated(updated: Map<string, any>): void | Promise<void>;
        firstUpdated(updated: Map<string, any>): void | Promise<void>;
        requestUpdate(props?: string[] | null | undefined): Promise<void>;
        updateDone(): Promise<void>;
    };
    readonly template: string;
    readonly props: {
        [x: string]: import("../types").Prop;
    };
    readonly observedAttributes: string[];
} & typeof ServerElement;
export default class WaferServer extends WaferServer_base {
    /**
     *
     * @param {import("../types").ServerOpts} opts
     * @param {import("../types").Registry} registry
     * Registry of components and their Wafer definitions that should be upgraded if
     * found in the component template
     */
    constructor({ shadow, tagName, attrs }: import("../types").ServerOpts, registry?: import("../types").Registry);
    /**
     * Type of shadow root (open/closed) or falsey for none
     *
     * @type {import("../types").ShadowOpts}
     */
    _shadow: import("../types").ShadowOpts;
    /**
     * Tag name that this component will be rendered within
     *
     * @type {string}
     */
    _tagName: string;
    /**
     * @type {import('../types').Registry}
     */
    _registry: import('../types').Registry;
    /**
     * Holds the server implementation of a shadow root if required
     *
     * @type {ServerElement | null}
     */
    shadowRoot: ServerElement | null;
    /**
     * Called to initialise the component
     */
    construct(): Promise<void>;
    /**
     * Create and attach a shadow root, which on the server is an instance
     * of a template {@link ServerElement}
     *
     * @param {Object} opts
     * @param {"open"|"closed"} opts.mode
     * @returns {ServerElement}
     */
    attachShadow({ mode }: {
        mode: "open" | "closed";
    }): ServerElement;
    /**
     * Called when an element is 'attached' to the DOM on the server. This is
     * called explicitly on the server before rendering takes place
     *
     * @returns {Promise<void>}
     */
    connectedCallback(): Promise<void>;
    /**
     * Returns true if the component has been rendered on the server
     * and has not yet been hydrated. Only true in client context
     *
     * @type {boolean}
     */
    get _needsRehydrating(): boolean;
    /**
     * Update the targets for property
     *
     * @param {string} name
     */
    updateTargets(name: string): Promise<void>;
}
import { ServerElement } from "./element.js";
export {};