/** @module Core */ /** */
import * as Rdl from "./ar-js-rdl";
import { i18n, WithT } from "i18next";
type _VNode = Identity<VNode>;
type _VProps = Identity<VProps>;
type _VText = Identity<VText>;
type _VTree = Identity<VTree>;
/**
 * Animation settings for visual components.
 */
type AnimationSettings = Partial<{
    charts: Partial<{
        onLoad: {
            enabled: boolean;
        };
        onHover: {
            enabled: boolean;
        };
        highlight: {
            enabled: boolean;
        };
    }>;
    table: {
        onHover: {
            enabled: boolean;
            backgroundColor: string;
            textColor?: string;
        } | {
            enabled: boolean;
            textColor: string;
        };
    };
}>;
/**
 * Definition of apply parameter step.
 */
type ApplyParameterStep = SetParameterStep | ToggleParameterStep | ResetParameterStep;
/** @hidden */ /** */
/** @hidden */
declare const arjsStyles: string;
/** Provides data for language and culture specific text formatting. */
declare const CultureInfo: {
    /**
     * Registers culture.
     * @deprecated
     * @param identifier Locale (language) identifier, i.e. 'en-US', 'zh-CN', 'ru-RU'.
     * @param data @see LocaleData specific for locale.
     */
    registerCulture(identifier: string, data: any): void;
};
/**
 * Provides tool for registering user defined functions.
 */
declare const CustomCode: {
    /**
     * Register user defined function which can be used in Report through {Code.<functionName>()}.
     * @param functions Array with user defined functions.
     *
     * ```javascript
     * var functions = [
     *   {
     *     name: 'leftPad',
     *     body: (value, length, character) => length > value.length ? character.repeat(length - value.length) + value : value,
     *     info: {
     *       description: 'Adds number of characters before value to adjust it to specified length.',
     *       example: 'Code.leftPad("hello", 16, " ")',
     *       syntax: 'Code.leftPad(<String>, <Int64>, <String>)'
     *     }
     *   }
     * ];
     *
     * CustomCode.registerFunctions(functions);
     * ```
     */
    registerFunctions: (functions: UserDefinedFunction[]) => void;
    /**
     * Gets the list of registered user defined functions.
     */
    getFunctions: () => UserDefinedFunction[];
};
interface DataArray extends Array<DataValue> {
}
/** @module Core */ /** */
/** @hidden */
type DataDocumentMapFn = () => {
    kids: DocumentMapNode[];
};
type DataFieldsRecords = {
    descriptors: Array<{
        Name: string;
        Type: VariantType | null;
    }>;
    records: IterableIterator<DataValue[]>;
};
interface DataObject {
    [key: string]: DataValue;
}
interface DataResourceProvider<TDataId, TError> {
    getData(dataInfo: TDataId): Promise<Result<string, TError>>;
    getDataSync(dataInfo: TDataId): Result<string, TError>;
}
type DataValue = boolean | number | string | null | DataArray | DataObject | undefined | Date;
type DocumentMapNode = {
    anchor: string;
    name: string | null;
    level: number;
    kids: DocumentMapNode[];
    isLeaf: boolean;
    page: number | null;
};
type DOMRenderingOptions = {
    /**
     * Specify elements ids to add 'searchHighlight' class
     */
    searchResults?: SearchResult[];
    /**
     * Provide Document instance for creatineg elements (window.document if undefined)
     */
    targetDocument?: Document;
    /**
     * Hide or show toggle and sort icons
     */
    hideInteractivity?: boolean;
};
/**
 * Report environment used for expressions calculation.
 */
type Environment = {
    /** Report name */
    readonly ReportName?: string;
    /** Report directory name */
    readonly ReportFolder?: string;
};
/**
 * Event listener
 * @typeparam TArgs event argument type
 */
interface Event<TArgs> {
    /**
     * Registers a new event handler.
     * @param eventHandler
     */
    register(eventHandler: EventHandler<TArgs>): UnregisterHandler;
}
/**
* Event Handler
* @typeparam TArgs event argument type
*/
declare type EventHandler<TArgs> = (args: TArgs) => void;
type ExprScopeSortState = {
    Expression: string;
    Direction: NonNullable<Rdl.SortExpression["Direction"]>;
};
type Failure<TErr> = {
    kind: "failure";
    error: TErr;
};
/** @module Core */ /** */
/**
 * Font file descriptor
 */
interface FontDescriptor {
    /** Font family name, e.g. "Segoe UI" */
    name: string;
    /** Font file URI, supported file formats are *.ttf, *.otf and *.woff */
    source: string | string[];
    /** Fallback fonts that will be searched on the local machine */
    locals?: string[];
    /** Font weight, e.g. "bold" */
    weight?: string;
    /** Font style, e.g. "italic" */
    style?: string;
    /** The font postscript name. */
    postscriptName?: string;
    /** True - to use the font as default font in PDF export. */
    useAsDefault?: boolean;
}
/**
 * Provides tools for registering fonts in CSS and pdf export.
 */
declare const FontStore: {
    /**
     * @param ...fonts List of FontDescriptor
     * Register specified fonts in CSS and pdf export. Helps display export correctly on machines where fonts can be missed.
     *
     * ```javascript
     * type FontDescriptor = {
     *     name: string,
     *     source: string,
     *     weight?: 'normal' | 'bold' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900',
     *     style?: 'normal' | 'italic' | 'oblique'
     * }
     *
     *
     * var arial = {
     *     name: 'Arial',
     *     source: 'fonts/arial.ttf',
     *     style: 'italic',
     *     weight: '700',
     * };
     *
     *
     * var gothic = {
     *     name: 'MS PGothic',
     *     source: 'fonts/MS-PGothic.ttf'
     * };
     *
     *
     * FontStore.registerFonts(arial);
     * //OR
     * FontStore.registerFonts(arial, gothic);
     * //OR
     * var fonts = [arial, gothic]; FontStore.registerFonts(...fonts);
     * ```
     *
     * @param configUri Path to fontsConfig.json file
     * Register fonts specified in сonfig file.
     * ```javascript
     * FontStore.registerFonts('./fontsConfig.json');
     * ```
     * @returns Promise<void>
     */
    registerFonts: ((...fonts: FontDescriptor[]) => Promise<void>) & ((configUri: string) => Promise<void>);
    /**
     * Get registered font descriptors.
     * @returns List of registered font descriptors.
     */
    getFonts: () => FontDescriptor[];
};
/** @hidden */
declare function getLicenseKey(): string;
type GetRequestInfo = {
    uri: string;
    method: "get";
    credentials?: "include";
    headers?: Record<string, string>;
};
type GetValuesResult = {
    [key: string]: {
        validValues: ParameterValue[];
        values: any[];
    };
};
/** @hidden */ /** */
type Identity<T> = T;
type InteractiveState = {
    Toggles: ToggleAction[];
    SortState: SortState;
};
type Layout<T> = LFunc<LFunc<T>>;
type LayoutOrder = NonNullable<Rdl.Report["LayoutOrder"]>;
/**
 *  Layout function type. Given some space performs element layout and returns layout result of type TR.
 *
 * @template TR
 * @param size
 */
type LFunc<TR> = (size: number) => Result$1<TR>;
type NodePatch = {
    id: string | null;
    style?: Object | null;
    children?: Array<VNode> | null;
    className?: string | null;
};
/** Special value to indicate that value is not set. */
declare const noValue: undefined;
/** Defines special value to indicate that value is not set. */
type NoValueType = typeof noValue;
/** Represents rendered report. */
declare class PageDocument {
    private readonly report;
    private readonly i18n;
    /** @hidden */
    get styles(): StaticStyle[];
    private static create;
    /** @hidden */
    readonly ctx: Environment;
    /** @hidden */
    readonly pageInfo: PageInfo | null;
    /** @hidden */
    readonly layoutOrder: LayoutOrder;
    /** @hidden */
    private sortState;
    /** @hidden */
    private recreateArguments;
    private dataLayoutFn;
    private resultTree;
    private readonly data;
    private constructor();
    /** @hidden */
    getLayout(interactivityState: InteractiveState): Promise<{
        layout: RunLayout;
        documentMap: DataDocumentMapFn;
    }>;
    /** @hidden */
    runRenderer(renderOptions?: RenderOptions): Promise<VDomRenderer>;
    /** Displays the browser's printing dialog.
     * @param renderOptions  Specifies the rendering options.
     * @param onProgress  Callback for printing progress notifications.
     * @param checkCancel  Allows to cancel report printing.
     */
    print(renderOptions?: RenderOptions, onProgress?: (pageCount: number) => void, checkCancel?: () => boolean): Promise<void>;
}
type PageInfo = {
    PageWidth: string;
    PageHeight: string;
    LeftMargin: string;
    RightMargin: string;
    TopMargin: string;
    BottomMargin: string;
};
/** PageReport class */
declare class PageReport {
    get viewSettings(): ViewSettings;
    private readonly i18n;
    private readonly webResourceProvider;
    private readonly animationSettings;
    /**
     * Create new instance of {@link PageReport} class.
     * @param options pageReport options
     * 	- language: report language. Default language is 'en'.
     */
    constructor(options?: Partial<{
        i18n: i18n;
        language: string;
        memoizeData: boolean;
        animations: AnimationSettings;
    }>);
    /** Gets the report name. */
    get name(): string;
    /** Gets the report parameters api. */
    get reportParameters(): ReportParameters;
    /** Gets the report resource locator instance. */
    get resourceLocator(): ResourceLocator;
    private _instance;
    private _parameters;
    private _context;
    /** Loads the report template.
     * @param report  URI or the report template or template object.
     * @param options  Execution time settings.
     */
    load(report: string | Rdl.Report, options?: {
        environment?: Environment;
        resourceLocator?: Partial<ResourceLocator>;
        reportParameters?: {
            Name: string;
            Value: ParameterVariant[];
        }[];
    }): Promise<void>;
    /** @hidden */
    execData(requiredParams: RequiredParametersDesc): Promise<{
        [name: string]: {
            validValues: any[];
            values: any;
            prompt: string;
        };
    }>;
    /** Starts rendering the report. */
    run(): Promise<PageDocument>;
}
/** Defines report parameter */
type Parameter = {
    /** Parameter descriptor */
    descriptor: ParameterDescriptorEx;
    /** Valid values */
    validValues: ParameterValue[];
    /** _true_ if valid values list was loaded */
    isValidValuesLoaded: boolean;
    /** Parameter values */
    values: ParameterVariant[];
    /** Shows error message for invalid parameter values */
    errorMessage: string | null;
};
/** @module Core/Parameters */ /** */
/** Defines parameter data type. */
type ParameterDataType = "Boolean" | "String" | "Integer" | "Float" | "Date" | "DateTime";
/** Defines report parameter descriptor */
type ParameterDescriptor = {
    /** Parameter name */
    name: string;
    /** Parameter data type */
    dataType: ParameterDataType;
    /** For multivalue parameter special value to indicate that all available values are selected */
    selectAllValue?: any;
    /** Allow blank */
    allowBlank: boolean;
    /** Allow null */
    nullable: boolean;
    /** Parameter is multivalue */
    multiValue: boolean;
    /** Specifies whether this parameter can have an empty array as its value. This setting is only available for multi-valued parameters */
    enableEmptyArray: boolean;
    /** Parameters on which parameter depends */
    dependsOn: string[];
    /** Format to display value */
    displayFormat: string;
};
/**
 * Parameter visual presentation settings.
 */
type ParameterDescriptorConfig = {
    /** Indicates that parameter is hidden. Hidden parameters are not visible in parameter panel. */
    hidden: boolean;
    /** Parameter value prompt. */
    prompt: string;
    /** Multiline. */
    multiline: boolean;
};
/**
 * Parameter descriptor.
 */
type ParameterDescriptorEx = ParameterDescriptor & ParameterDescriptorConfig;
/** Defines parameter state */
type ParameterState = {
    values: ParameterVariant[];
    validValues: {
        loaded: true;
        values: {
            value: ParameterVariant;
            label: ParameterVariant;
        }[];
    } | {
        loaded: false;
    };
    status: {
        isValid: true;
    } | {
        isValid: false;
        error: string;
    };
};
/** @hidden */
declare enum ParameterStatus {
    ok = 0,
    expectValue = 1,
    hasOutstandingDependencies = 2,
    validationFailed = 3,
    dynamicValuesUnavailable = 4,
    communicating = 5,
    isValidation = 6
}
/**
 * Defines parameter value
 */
type ParameterValue = {
    /** Label to display */
    label: string;
    /** Value */
    value: ParameterVariant;
    /** Additional fields for extended parameter view */
    fields?: any[];
};
/** Type of parameter value */
type ParameterVariant = string | number | boolean | Date | null | NoValueType | SelectAllType;
type PostRequestInfo = {
    uri: string;
    method: "post";
    credentials?: "include";
    headers?: Record<string, string>;
    body?: any;
};
declare namespace rdlxparams_d {
    export { rdlxparams_d_ParameterStatus as ParameterStatus };
    export type { rdlxparams_d_ParameterVariant as ParameterVariant, rdlxparams_d_GetValuesResult as GetValuesResult };
}
type rdlxparams_d_GetValuesResult = GetValuesResult;
type rdlxparams_d_ParameterStatus = ParameterStatus;
declare const rdlxparams_d_ParameterStatus: typeof ParameterStatus;
type rdlxparams_d_ParameterVariant = ParameterVariant;
/** @hidden */
declare function readDataRecords(dataSource: Rdl.DataSource, dataSet: Rdl.DataSet, getResourceUri: (resourceID: string) => string, webResProvider?: WebResourceProvider): Promise<DataFieldsRecords | null>;
type RendererOptions = {
    TableStaticHeaders: boolean;
};
/** Document render options */
type RenderOptions = {
    /** Renders document without splitting the big content to pages. */
    galleyMode: boolean;
    /** Holds sorts/toggles state of the document. */
    interactivityActions: Array<{
        Type: "toggle";
        Data: string;
    } | {
        Type: "sort";
        Data: string;
    }>;
    /** Force cell-based layout. */
    forceCellbased?: boolean;
};
/** Defines report parameters */
type ReportParameters = {
    /**
     * Applies parameters values defined by steps
     * @param steps definitions of apply parameter steps
     */
    applySteps(steps: ApplyParameterStep[]): Promise<void>;
    /**
     * Returns parameters values for ParametersView.
     * @param knownValues Known parameters values.
     * @param requiredParameters Required parameters.
     */
    getValuesFor(knownValues: {
        [name: string]: ParameterVariant | ParameterVariant[];
    }, requiredParameters: {
        [name: string]: {
            fields: string[];
        } | null;
    }): Promise<GetValuesResult>;
    /**
     * Returns current parameters values.
     */
    getValues(): {
        [name: string]: ParameterState;
    };
    /**
     * Returns parameters descriptors.
     */
    getDescriptors(): {
        [name: string]: ParameterDescriptorEx;
    };
};
/** @module Core */ /** */
/** @hidden */
type RequiredParametersDesc = Record<string, {
    fields: string[];
} | null>;
/**
 * Definition of reset parameter step.
 */
type ResetParameterStep = {
    /**
     * The name of the parameter to be affected.
     */
    Name: string;
    /**
     * Parameter update type.
     */
    Type: "Reset";
};
type ResolvedStyle = {
    [propName: string]: string;
};
/**
 * Provide tools for accessing external resources by URIs.
 */
type ResourceLocator = {
    /**
     * Fetches and returns the content for the resource identified by the given URI. Resolves to `null` when the provider confirms the resource is missing and rejects if the lookup fails (for example, due to HTTP errors).
     * @param {string} uri — URI of the resource to fetch.
     * @returns {Promise<T|null>} — A promise that resolves to the resource content parsed as type T, or null if the resource is not found.
     *
     * @example
     * ```ts
     * const getResource = (id: string) =>
     * 	fetch(getResourceUri(id)).then((response) => response.json());
     * ```
     */
    getResource: <T>(uri: string) => Promise<T | null>;
    /**
     * Returns an absolute URI for the resource identified by resourceID, using the provider's base path and ID scheme.
     * @param {string} resourceID — Identifier of the resource to locate.
     * @returns {string} — Absolute URI that can be used to fetch the resource.
     *
     * @example
     * ```ts
     * const getResourceUri = (resourceID: string) => {
     * 	const mappings = [
     * 		{ prefix: 'report://', offset: 9, replacement: '/reports/' },
     * 		{
     * 			prefix: 'masterReport://',
     * 			offset: 15,
     * 			replacement: '/masterReports/',
     * 		},
     * 		{ prefix: 'theme://', offset: 8, replacement: '/themes/' },
     * 		{ prefix: 'stylesheet://', offset: 13, replacement: '/stylesheets/' },
     * 		{ prefix: 'library://', offset: 10, replacement: '/libraries/' },
     * 	];
     * 	const mapping = mappings.find((m) => resourceID.startsWith(m.prefix));
     * 	return mapping
     * 		? `${mapping.replacement}${resourceID.substring(mapping.offset)}`
     * 		: resourceID;
     * };
     * ```
     */
    getResourceUri: (resourceID: string) => string;
    /**
     * Creates new ResourceLocator instance based on current one base path.
     * @param {string} reportName Relative path for new report.
     * @returns {ResourceLocator} — Provide tools for accessing external resources by URIs.
     */
    fork(reportName: string): ResourceLocator;
};
type Result<TR, TErr> = Success<TR> | Failure<TErr>;
/**
 * Defines the layout result type (for covariance).
 *
 * @typeparam TR
 */
type Result$1<TR> = {
    /** Gets the slice size. */
    Size: number;
    /** Gets the slice content. */
    Body: TR | null;
    /** Gets the slice tail. */
    Tail: LFunc<TR> | null;
    /** Gets true if layout failed. */
    IsFailed(): boolean;
    /**
     * Gets true is layout succeeded and there's a continuation.
     * Also returns true in case PageBreakBefore but not PageBreakAfter.
     */
    IsSplit(): boolean;
    /**
     *  Gets true is layout succeeded and there's no reminder (or reminder is zero).
     *  Explicitly check IsPageBreak result to detect latter case.
     */
    IsCompleted(): boolean;
    /**
     * Gets true the result is page break i.e. body is zero and there's a reminder.
     */
    IsPageBreak(): boolean;
    /**
    *  Gets true the slice succeeded (split) while the tail is zero layout.
    */
    IsPageBreakAfter(): boolean;
    /**
    *  Gets true if body is not empty
    */
    IsEmpty(): boolean;
};
/** @hidden */
type RunLayout = (rendererOptions: RendererOptions) => SectionLayout[];
/** Scalar value. */
type ScalarValue = string | number | boolean | Date | null;
type ScopeSortState = {
    [ExpressionScope: string]: ExprScopeSortState;
};
/** @hidden */
type SearchOptions = {
    PageIndex: number;
    ItemIndex: number;
    Text: string;
    MatchCase: boolean;
    WholeWord: boolean;
    SearchBackward: boolean;
};
/** @hidden */ /** */
type SearchResult = {
    id: string;
};
type SectionLayout = {
    L: Layout<VNode>;
    PageSize: SectionPageSize;
    ReportSectionDisplayName: string;
    isEmptyPage: boolean;
    CellSize: {
        CellWidth: number;
        CellHeight: number;
    } | undefined;
    CellCount: {
        ColumnCount: number;
        RowCount: number;
    } | undefined;
};
type SectionPageSize = {
    PageWidth: string;
    PageHeight: string;
    RightMargin: string;
    LeftMargin: string;
    TopMargin: string;
    BottomMargin: string;
};
/** Special value for multivalue parameter to indicate that all values are set. */
declare const selectAll: SelectAllType;
/** Defines special value for multivalue parameter to indicate that all values are set. */
type SelectAllType = {
    /** @hidden */
    selectAll: "$selectAll";
};
/**
 * Set ARJS license key
 * @param key license key value
 */
declare function setLicenseKey(key: string): void;
/**
 * Definition of set parameter step.
 */
type SetParameterStep = {
    /**
     * The name of the parameter to be affected.
     */
    Name: string;
    /**
     * Parameter value to set.
     */
    Value: VariantValue;
    /**
     * Parameter update type.
     */
    Type: "Set";
};
type SortState = {
    [ScopeId: number]: ScopeSortState;
};
type StaticStyle = {
    className: string;
    style: ResolvedStyle;
};
type Success<TR> = {
    kind: "success";
    value: TR;
};
type ToggleAction = {
    Type: "toggle";
    ScopeId: number;
    ItemPath: Array<string>;
};
/**
 * Definition of toggle parameter step.
 */
type ToggleParameterStep = {
    /**
     * The name of the parameter to be affected.
     */
    Name: string;
    /**
     * Parameter value to toggle.
     */
    Value: VariantValue;
    /**
     * Parameter update type.
     */
    Type: "Toggle";
};
/** Unsubscribe event handler */
declare type UnregisterHandler = () => void;
/**
 * User defined function for using in report expressions
 */
type UserDefinedFunction = {
    name: string;
    body: (...args: any[]) => any;
    info?: {
        description?: string;
        example?: string;
        syntax?: string;
    };
};
//# sourceMappingURL=expressionNode.d.ts.map
type VariantType = "Null" | "Bool" | "Int32" | "Int64" | "UInt64" | "Float" | "Double" | "Decimal" | "TimeSpan" | "Date" | "String" | "Enum" | "Object";
/** Variant Value. Can be used as parameter value. */
type VariantValue = ScalarValue | ScalarValue[] | {
    [index: string]: ScalarValue;
};
/** @hidden */
declare class VDomRenderer {
    private readonly documentMapFn;
    private readonly styles;
    private readonly galleyMode;
    private readonly i18n?;
    static create(pageDoc: PageDocument, renderOptions?: RenderOptions, i18n?: i18n): Promise<VDomRenderer>;
    static renderToDOM(content: VNode, patches?: NodePatch[][], options?: DOMRenderingOptions): HTMLElement;
    static getCssString(style: ResolvedStyle): string;
    private readonly language;
    private readonly pageGenerator;
    private readonly pages;
    private readonly patches;
    private readonly tocLabels;
    private constructor();
    render(): IterableIterator<{
        pageCount: number;
        isComplete: boolean;
    }>;
    getPage(pIndex: number): VNode | null;
    getDelayedContent(pageIndex: number): NodePatch[][] | null;
    getDocumentMap(): {
        kids: DocumentMapNode[];
    };
    resolveBookmark(label: string): number | null;
    getContent(): {
        pages: VNode[];
        patches: NodePatch[][][];
        styles: StaticStyle[];
    };
    findText(options: SearchOptions): IterableIterator<{
        text: string;
        itemId: string;
        pageIndex: number;
        itemIndex: number;
        position: number;
        length: number;
    }>;
    print(onProgress?: (pageCount: number) => void, checkCancel?: () => boolean): Promise<void>;
    getFontFaces(): string;
    private _e;
}
/** @hidden */
declare const Version: string;
/**
 * Viewer settigs for report.
 */
type ViewSettings = {
    /** List of document view types. */
    restrictViewTypes: ViewType[];
    /** JSON string representing parameters view settings */
    parametersView?: string;
};
/**
 * Document view type.
 *  PrintLayout:
 *    View document ready for print - with page sizes defined in definition.
 *  Galley:
 *    View document as web page - page sizes are ignored and document takes required space.
 *  Pageless:
 *    View pageless document that supports scrollable report items and multiple sections.
 */
type ViewType = "PrintLayout" | "Galley" | "Pageless";
/** @hidden */
declare namespace VirtualDOM {
    type VNode = _VNode;
    type VTree = _VTree;
    type VText = _VText;
    type VProps = _VProps;
    const h: (tagName: string, properties?: Partial<VProps> | undefined, content?: string | (string | VTree | null)[] | undefined) => VNode;
    const create: (node: VNode, opts?: {
        document: Document;
    } | undefined) => Element;
}
type VNode = {
    type: "VirtualNode";
    tagName: string;
    properties: VProps;
    children: VTree[];
};
type VProps = {
    [index: string]: any;
    /** custom XML namespace */
    namespace?: string;
    /** Callback which is called after node was rendered to DOM */
    hooks?: ((element: Element) => void)[];
    /** CSS style declaration */
    style: {
        [index: string]: string | null;
    };
    /** XML node attrubutes */
    attributes: {
        [index: string]: string | null;
    };
};
type VText = {
    type: "VirtualText";
    text: string;
};
type VTree = VNode | VText;
type WebError = {
    status?: number;
    message: string;
};
type WebRequestInfo = GetRequestInfo | PostRequestInfo;
type WebResourceProvider = DataResourceProvider<WebRequestInfo, WebError>;
/** @hidden */
declare const withLocalizedErrors: (i18n: WithT) => <U extends any[], TR>(fn: (...args: U) => TR) => (...args: U) => TR;
/** @hidden */
declare const withLocalizedErrorsAsync: (i18n: WithT) => <U extends any[], TR>(fn: (...args: U) => Promise<TR>) => (...args: U) => Promise<TR>;
export { Rdl };
export { CultureInfo, CustomCode, FontStore, PageDocument, PageReport, VDomRenderer, Version, VirtualDOM, arjsStyles, getLicenseKey, noValue, rdlxparams_d as rdlxParams, readDataRecords, selectAll, setLicenseKey, withLocalizedErrors, withLocalizedErrorsAsync };
export type { AnimationSettings, Environment, Event, EventHandler, FontDescriptor, NoValueType, Parameter, ParameterDataType, ParameterDescriptor, ParameterDescriptorConfig, ParameterDescriptorEx, ParameterValue, ParameterVariant, RenderOptions, ReportParameters, ResourceLocator, SelectAllType, UnregisterHandler };
