import { App } from '@vue/runtime-core';
import { Component } from '@vue/runtime-core';
import { ComponentInternalInstance } from '@vue/runtime-core';
import { pipeToWebWritable } from '@vue/server-renderer';
import { renderToNodeStream } from '@vue/server-renderer';
import { renderToSimpleStream } from '@vue/server-renderer';
import { renderToString } from '@vue/server-renderer';
import { renderToWebStream } from '@vue/server-renderer';
import { Slots } from '@vue/runtime-core';
import { ssrGetDynamicModelProps } from '@vue/server-renderer';
import { includeBooleanAttr as ssrIncludeBooleanAttr } from '@vue/shared';
import { ssrInterpolate } from '@vue/server-renderer';
import { ssrLooseContain } from '@vue/server-renderer';
import { ssrLooseEqual } from '@vue/server-renderer';
import { ssrRenderAttr } from '@vue/server-renderer';
import { ssrRenderAttrs } from '@vue/server-renderer';
import { ssrRenderClass } from '@vue/server-renderer';
import { ssrRenderDynamicAttr } from '@vue/server-renderer';
import { ssrRenderDynamicModel } from '@vue/server-renderer';
import { ssrRenderList } from '@vue/server-renderer';
import { ssrRenderSuspense } from '@vue/server-renderer';
import { ssrRenderTeleport } from '@vue/server-renderer';
import { VNode } from '@vue/runtime-core';

/**
 * @public
 */
export declare type CallbackType = Function;

/**
 * @public
 */
export declare interface CommonMapParams {
    [key: string]: NeedToTyped;
}

/**
 * css node declaration type
 *
 * @public
 */
declare interface CssDeclarationType {
    type: string;
    property: string;
    value: string | number;
}

/**
 * get unique id at current vue app instance
 *
 * @param app - vue app instance
 *
 * @public
 */
export declare function getCurrentUniqueId(app: App): number;

/**
 * options type of initialization parameters
 *
 * @public
 */
declare interface HippyAppOptions {
    appName: string;
    iPhone?: IphoneOptions;
    styleOptions?: {
        beforeLoadStyle?: (decl: CssDeclarationType) => CssDeclarationType;
        ratioBaseWidth?: number;
    };
    silent?: boolean;
    trimWhitespace?: boolean;
    ssrNodeList?: SsrNode_2[];
}

/**
 * Additional configuration information for iPhone
 *
 * @public
 */
declare interface IphoneOptions {
    statusBar?: {
        disabled?: boolean;
        backgroundColor?: number;
        backgroundImage?: string;
    };
}

/**
 * hippy vue next server renderer type，export main method from vue/server-renderer, and modify some api with hippy
 */
/**
 * @public
 */
export declare type NeedToTyped = any;

/**
 * @public
 */
declare type NeedToTyped_2 = any;

export { pipeToWebWritable }

declare type Props = Record<string, unknown>;

declare type Props_2 = Record<string, unknown>;

declare type PushFn = (item: SSRBufferItem) => void;

declare type PushFn_2 = (item: SSRBufferItem_2) => void;

/**
 * convert hippy node list json string to hippy native node tree
 *
 * @param app - vue ssr app
 * @param options - ssr options
 *
 * @public
 */
export declare function renderToHippyList(app: App, options: SsrRenderOption): Promise<SsrNode[] | null>;

export { renderToNodeStream }

export { renderToSimpleStream }

export { renderToString }

export { renderToWebStream }

declare type SSRBuffer = SSRBufferItem[] & {
    hasAsync?: boolean;
};

declare type SSRBuffer_2 = SSRBufferItem_2[] & {
    hasAsync?: boolean;
};

declare type SSRBufferItem = string | SSRBuffer | Promise<SSRBuffer>;

declare type SSRBufferItem_2 = string | SSRBuffer_2 | Promise<SSRBuffer_2>;

/**
 * SSR common type
 *
 * @public
 */
export declare interface SsrCommonParams {
    [key: string]: NeedToTyped;
}

/**
 * SSR common type
 *
 * @public
 */
declare interface SsrCommonParams_2 {
    [key: string]: NeedToTyped_2;
}

/**
 * get hippy ssr directive props
 *
 * @public
 */
export declare function ssrGetDirectiveProps(): unknown;

export { ssrGetDynamicModelProps }

/**
 * generate hippy unique id at ssr. this is ssr helper
 *
 * @public
 */
export declare function ssrGetUniqueId(): number;

export { ssrIncludeBooleanAttr }

export { ssrInterpolate }

export { ssrLooseContain }

export { ssrLooseEqual }

/**
 * SSR Node type
 *
 * @public
 */
export declare interface SsrNode {
    id: number;
    pId?: number;
    index: number;
    name: string;
    props: SsrNodeProps;
    tagName?: string;
    children?: SsrNode[];
}

/**
 * SSR Node type
 *
 * @public
 */
declare interface SsrNode_2 {
    id: number;
    pId?: number;
    index: number;
    name: string;
    props: SsrNodeProps_2;
    tagName?: string;
    children?: SsrNode_2[];
}

/**
 * SSR Node props type
 *
 * @public
 */
export declare type SsrNodeProps = SsrCommonParams;

/**
 * SSR Node props type
 *
 * @public
 */
declare type SsrNodeProps_2 = SsrCommonParams_2;

export { ssrRenderAttr }

export { ssrRenderAttrs }

export { ssrRenderClass }

/**
 * render component for server side
 *
 * @param comp - vue component
 * @param props - component props
 * @param children - component children
 * @param parentComponent - parent
 * @param slotScopeId - slot scoped id
 *
 * @public
 */
export declare function ssrRenderComponent(comp: Component, props?: Props_2 | null, children?: Slots | SSRSlots | null, parentComponent?: ComponentInternalInstance | null, slotScopeId?: string): SSRBuffer_2 | Promise<SSRBuffer_2>;

export { ssrRenderDynamicAttr }

export { ssrRenderDynamicModel }

export { ssrRenderList }

/**
 * SSR render options type
 */
declare interface SsrRenderOption {
    rootContainer: string;
    ssrOptions?: HippyAppOptions;
    context?: SsrRequestContext;
}

/**
 * render ssr slot.
 * because template-compiled slots are always rendered as fragments, the vue/server-renderer wrap
 * fragment content in html comment. like \<!--[--\>\{content\}\<!--]--\>. but hippy didn't recognize.
 * so we use hippy comment node to replace it.
 *
 * @param slots - slot list
 * @param slotName - slot name
 * @param slotProps - slot props
 * @param fallbackRenderFn - fallback render function
 * @param push - push function
 * @param parentComponent - parent component
 * @param slotScopeId - slot scope id
 *
 * @public
 */
export declare function ssrRenderSlot(slots: SSRSlots, slotName: string, slotProps: Props, fallbackRenderFn: (() => void) | null, push: PushFn, parentComponent: NeedToTyped, slotScopeId?: string): void;

/**
 * get hippy ssr style object
 *
 * @param raw - raw style
 *
 * @public
 */
export declare function ssrRenderStyle(raw: unknown): string;

export { ssrRenderSuspense }

export { ssrRenderTeleport }

/**
 * render vNode
 *
 * @param push - push function
 * @param vnode - vnode
 * @param parentComponent - parent component
 * @param slotScopeId - slot scoped id
 *
 * @public
 */
export declare function ssrRenderVNode(push: PushFn_2, vnode: VNode & {
    slotScopeIds?: string[];
}, parentComponent: ComponentInternalInstance, slotScopeId?: string): void;

/**
 * SSR Request context type
 *
 * @public
 */
export declare interface SsrRequestContext {
    isIOS?: boolean;
    dimensions?: {
        screen: {
            width: number;
            height: number;
            statusBarHeight: number;
        };
    };
}

declare type SSRSlot = (props: Props, push: PushFn, parentComponent: NeedToTyped, scopeId: string | null) => void;

declare type SSRSlots = Record<string, SSRSlot>;

export { }