@devtable/dashboard 8.51.0 → 8.51.2

package/dist/plugins/viz-components/text/viz-text.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { VizViewProps } from '~/types/plugin';
+export declare const VizText: (({ context }: VizViewProps) => JSX.Element) & {
+    displayName: string;
+};

package/dist/plugins/viz-components/viz-merico-gqm/error-figure.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const MericoGQMErrorFigure: () => JSX.Element;

package/dist/plugins/viz-components/viz-merico-gqm/index.d.ts

@@ -0,0 +1,2 @@
+import { VizComponent } from '../../../types/plugin';
+export declare const MericoGQMVizComponent: VizComponent;

package/dist/plugins/viz-components/viz-merico-gqm/request/call-expert-system.d.ts

@@ -0,0 +1,27 @@
+import { AnyObject } from '~/types';
+import { IMericoGQMConf } from '../type';
+interface IExpertSystemReply {
+    dashboard: string;
+    panel: string;
+    actor: string;
+    interpretation: {
+        json: {
+            hint: string;
+            message: string;
+        };
+        html: string;
+    };
+}
+interface IExpertSystemResponse {
+    query_id: string;
+    submitted: string;
+    replied: string;
+    replies: Array<IExpertSystemReply>;
+}
+interface ICallExpertSystem {
+    baseURL?: string;
+    conf: IMericoGQMConf;
+    data: AnyObject[];
+}
+export declare const callExpertSystem: ({ conf, data }: ICallExpertSystem) => () => Promise<IExpertSystemResponse | undefined>;
+export {};

package/dist/plugins/viz-components/viz-merico-gqm/type.d.ts

@@ -0,0 +1,7 @@
+export interface IMericoGQMConf {
+    expertSystemURL: string;
+    path: string;
+    goal: string;
+    question: string;
+}
+export declare const DEFAULT_CONFIG: IMericoGQMConf;

package/dist/plugins/viz-components/viz-merico-gqm/viz-merico-gqm-panel.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { VizConfigProps } from '../../../types/plugin';
+export declare function VizMericoGQMPanel({ context }: VizConfigProps): JSX.Element;

package/dist/plugins/viz-components/viz-merico-gqm/viz-merico-gqm.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { VizViewProps } from '../../../types/plugin';
+export declare function VizMericoGQM({ context }: VizViewProps): JSX.Element | null;

package/dist/plugins/viz-manager/components.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+import { IPanelInfoEditor } from '~/types/plugin';
+import { IPanelInfo, IVizManager } from './types';
+import { ITemplateVariable } from '~/utils/template';
+export declare type IViewPanelInfo = IPanelInfo & {
+    layout: {
+        w: number;
+        h: number;
+    };
+};
+export declare type IViewComponentProps<TDebug = Record<string, unknown>> = {
+    panel: IViewPanelInfo;
+    data: $TSFixMe;
+    vizManager: IVizManager;
+    variables: ITemplateVariable[];
+} & TDebug;
+export declare const VizViewComponent: <T>(props: IViewComponentProps<T>) => JSX.Element;
+export declare type IConfigComponentProps<TDebug = Record<string, unknown>> = {
+    panel: IPanelInfo;
+    panelInfoEditor: IPanelInfoEditor;
+    vizManager: IVizManager;
+    variables: ITemplateVariable[];
+    data: $TSFixMe;
+} & TDebug;
+export declare const VizConfigComponent: <T>(props: IConfigComponentProps<T>) => JSX.Element;

package/dist/plugins/viz-manager/impl.d.ts

@@ -0,0 +1,10 @@
+import { IPluginManager, VizComponent, VizInstance } from '~/types/plugin';
+import { IPanelInfo, IVizManager } from './types';
+export declare class VizManager implements IVizManager {
+    private pluginManager;
+    private instances;
+    constructor(pluginManager: IPluginManager);
+    get availableVizList(): VizComponent[];
+    resolveComponent(name: string): VizComponent;
+    getOrCreateInstance(panel: IPanelInfo): VizInstance;
+}

package/dist/plugins/viz-manager/index.d.ts

@@ -0,0 +1,4 @@
+export { VizManager } from './impl';
+export type { IVizManager, IPanelInfo } from './types';
+export { VizConfigComponent, VizViewComponent } from './components';
+export type { IViewPanelInfo, IViewComponentProps } from './components';

package/dist/plugins/viz-manager/types.d.ts

@@ -0,0 +1,8 @@
+import { IDashboardPanel } from '~/types';
+import { VizComponent, VizInstance } from '~/types/plugin';
+export declare type IPanelInfo = Omit<IDashboardPanel, 'layout' | 'variables' | 'style'>;
+export interface IVizManager {
+    readonly availableVizList: VizComponent[];
+    resolveComponent(type: string): VizComponent;
+    getOrCreateInstance(panel: IPanelInfo): VizInstance;
+}

package/dist/service-locator/index.d.ts

@@ -0,0 +1,27 @@
+export declare class Token<T> {
+    symbol: symbol;
+    constructor(id: string);
+}
+export declare function token<T>(id: string): Token<T>;
+export interface IDisposable {
+    dispose(): void;
+}
+export interface IServiceLocator {
+    provideFactory: <T>(token: Token<T>, factory: (env: IServiceLocator) => T) => this;
+    provideValue: <T>(token: Token<T>, value: T) => this;
+    createScoped: () => IServiceLocator;
+    get: <T>(token: Token<T>) => T | undefined;
+    dispose: () => void;
+    getRequired<T>(token: Token<T>): T;
+}
+export declare class ServiceLocator implements IServiceLocator, IDisposable {
+    protected parent?: IServiceLocator;
+    protected factoryRegistry: Map<symbol, (env: IServiceLocator) => unknown>;
+    protected instanceRegistry: Map<symbol, unknown>;
+    createScoped(): IServiceLocator;
+    getRequired<T>(token: Token<T>): T;
+    get<T>(token: Token<T>): T | undefined;
+    provideFactory<T>(token: Token<T>, factory: (env: IServiceLocator) => T): this;
+    provideValue<T>(token: Token<T>, value: T): this;
+    dispose(): void;
+}

package/dist/service-locator/use-service-locator.d.ts

@@ -0,0 +1,8 @@
+import React, { ReactNode } from 'react';
+import { IServiceLocator } from '~/service-locator/index';
+export declare const ServiceLocatorContext: React.Context<IServiceLocator>;
+export declare function ServiceLocatorProvider(props: {
+    configure: (services: IServiceLocator) => IServiceLocator;
+    children: ReactNode;
+}): JSX.Element;
+export declare function useServiceLocator(): IServiceLocator;

package/dist/styles/action-icon-group-style.d.ts

@@ -0,0 +1,22 @@
+export declare const ActionIconGroupStyle: {
+    '> button': {
+        '&:first-of-type': {
+            borderTopRightRadius: number;
+            borderBottomRightRadius: number;
+            borderRightWidth: number;
+        };
+        ':not(:first-of-type):not(:last-of-type)': {
+            borderTopRightRadius: number;
+            borderBottomRightRadius: number;
+            borderTopLeftRadius: number;
+            borderBottomLeftRadius: number;
+            borderLeftWidth: number;
+            borderRightWidth: number;
+        };
+        '&:last-of-type': {
+            borderTopLeftRadius: number;
+            borderBottomLeftRadius: number;
+            borderLeftWidth: number;
+        };
+    };
+};

package/dist/styles/common-html-content-style.d.ts

@@ -0,0 +1,2 @@
+import { Sx } from '@mantine/core';
+export declare const CommonHTMLContentStyle: Sx;

package/dist/styles/register-themes.d.ts

@@ -0,0 +1 @@
+export declare function registerThemes(): void;

package/dist/types/dashboard.d.ts

@@ -0,0 +1,78 @@
+import { AnyObject } from '~/types/utils';
+import { ITemplateVariable } from '~/utils/template';
+import { FilterModelSnapshotOut } from '../model';
+import { QueryModelSnapshotIn } from '../model/queries';
+import { SQLSnippetModelSnapshotIn } from '../model/sql-snippets';
+export interface IVizConfig {
+    type: string;
+    conf: AnyObject;
+}
+interface IDashboardPanelStyle {
+    border: {
+        enabled: boolean;
+    };
+}
+export interface IDashboardPanel {
+    id: string;
+    title: string;
+    description: string;
+    layout: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        moved?: boolean;
+        static?: boolean;
+    };
+    queryID: string;
+    viz: IVizConfig;
+    style: IDashboardPanelStyle;
+    variables: ITemplateVariable[];
+}
+export declare enum DashboardMode {
+    Use = "use",
+    Edit = "edit"
+}
+export interface IDashboardDefinition {
+    sqlSnippets: SQLSnippetModelSnapshotIn[];
+    queries: QueryModelSnapshotIn[];
+    mock_context: Record<string, $TSFixMe>;
+}
+export declare enum EViewComponentType {
+    Division = "div",
+    Modal = "modal",
+    Tabs = "tabs"
+}
+export declare const ViewComponentTypeName: {
+    div: string;
+    tabs: string;
+    modal: string;
+};
+export declare const ViewComponentTypeBackground: {
+    div: string;
+    modal: string;
+    tabs: string;
+};
+export declare const ViewComponentTypeColor: {
+    div: string;
+    modal: string;
+    tabs: string;
+};
+export interface IDashboardView {
+    id: string;
+    name: string;
+    type: EViewComponentType;
+    config: Record<string, any>;
+    panelIDs: string[];
+}
+export interface IDashboard {
+    id: string;
+    name: string;
+    group: string;
+    definition: IDashboardDefinition;
+    views: IDashboardView[];
+    panels: IDashboardPanel[];
+    filters: FilterModelSnapshotOut[];
+    version: string;
+}
+export {};

package/dist/types/filter.d.ts

@@ -0,0 +1,8 @@
+export declare enum DashboardFilterType {
+    Select = "select",
+    TreeSelect = "tree-select",
+    MultiSelect = "multi-select",
+    TextInput = "text-input",
+    Checkbox = "checkbox",
+    DateRange = "date-range"
+}

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dashboard';
+export * from './filter';
+export type { AnyObject, Ready } from './utils';

package/dist/types/plugin/index.d.ts

@@ -0,0 +1,221 @@
+import { EventEmitter2 } from 'eventemitter2';
+import React from 'react';
+import { IVizManager } from '~/plugins';
+import { AnyObject } from '~/types';
+import { ITemplateVariable } from '~/utils/template';
+import { PanelModelInstance } from '~/model/panels';
+/**
+ * Basic information of a viz component instance
+ */
+export interface VizInstance {
+    id: string;
+    name: string;
+    type: string;
+    messageChannels: IMessageChannels;
+    instanceData: PluginStorage;
+}
+/**
+ * Props to render the view of viz component
+ */
+export interface VizViewProps {
+    instance: VizInstance;
+    context: VizViewContext;
+}
+export interface IWatchOptions {
+    fireImmediately?: boolean;
+}
+export interface PluginStorage {
+    getItem<T>(key: string | null): Promise<T>;
+    setItem<T>(key: string | null, item: T): Promise<T>;
+    deleteItem(key: string): Promise<void>;
+    watchItem<T>(key: string | null, callback: (value: T, previous?: T) => void, options?: IWatchOptions): () => void;
+}
+export interface IColorPaletteItem {
+    name: string;
+    type: string;
+    category: string;
+}
+export interface ISingleColor extends IColorPaletteItem {
+    type: 'single';
+    value: string;
+}
+export interface IColorInterpolation extends IColorPaletteItem {
+    type: 'interpolation';
+    displayName: string;
+    /**
+     * Map a value (0-100) to a color
+     * @param value
+     */
+    getColor: (value: number) => string;
+}
+export interface ColorPalette {
+    getColor(colorInfo: IColorPaletteItem): (value: unknown) => string;
+}
+export interface IMessageChannels {
+    globalChannel: EventEmitter2;
+    getChannel(name: string): EventEmitter2;
+}
+export interface VizContext {
+    pluginData: PluginStorage;
+    instanceData: PluginStorage;
+    colorPalette: ColorPalette;
+    variables: ITemplateVariable[];
+    locale: string;
+    msgChannels: IMessageChannels;
+    data: unknown;
+    vizManager: IVizManager;
+}
+declare type Setter<T> = (val: T) => void;
+export interface IPanelInfoEditor {
+    setTitle: Setter<string>;
+    setDescription: Setter<string>;
+    setQueryID: Setter<string>;
+}
+export interface VizConfigContext extends VizContext {
+    panelInfoEditor: IPanelInfoEditor;
+}
+export interface VizViewContext extends VizContext {
+    viewport: {
+        width: number;
+        height: number;
+    };
+}
+export interface VizConfigProps {
+    instance: VizInstance;
+    context: VizConfigContext;
+}
+export interface IConfigMigrationContext {
+    configData: PluginStorage;
+}
+export interface IConfigMigrationExecContext extends IConfigMigrationContext {
+    panelModel: PanelModelInstance;
+}
+export interface VizComponent {
+    name: string;
+    displayName?: string;
+    displayGroup?: string;
+    viewRender: React.ComponentType<VizViewProps>;
+    configRender: React.ComponentType<VizConfigProps>;
+    migrator: IPanelScopeConfigMigrator;
+    createConfig: () => {
+        version: number;
+        config: AnyObject;
+    };
+    triggers?: ITriggerSchema[];
+}
+export interface IPanelScopeConfigMigrator {
+    needMigration(ctx: IConfigMigrationContext): Promise<boolean>;
+    migrate(ctx: IConfigMigrationExecContext): Promise<void>;
+}
+export interface IConfigMigrator extends IPanelScopeConfigMigrator {
+    migrate(ctx: IConfigMigrationContext): Promise<void>;
+}
+export interface IPluginManifest {
+    viz: VizComponent[];
+    color: IColorPaletteItem[];
+}
+export interface IDashboardPlugin {
+    id: string;
+    version: string;
+    manifest: IPluginManifest;
+}
+export interface IPluginManager {
+    install(plugin: IDashboardPlugin): void;
+    installedPlugins: IDashboardPlugin[];
+    factory: {
+        viz: (name: string) => VizComponent;
+    };
+}
+export interface IPayloadVariableSchema {
+    name: string;
+    description: string;
+    valueType: 'string' | 'number' | 'object';
+}
+export interface IInteractionConfigProps {
+    instance: VizInstance;
+}
+export interface ITriggerConfigProps extends IInteractionConfigProps {
+    trigger: ITrigger;
+    sampleData: Record<string, unknown>[];
+}
+export interface IOperationConfigProps extends IInteractionConfigProps {
+    operation: IDashboardOperation;
+    variables: IPayloadVariableSchema[];
+}
+export interface ITriggerSchema {
+    id: string;
+    displayName: string;
+    payload: IPayloadVariableSchema[];
+    configRender: React.ComponentType<ITriggerConfigProps>;
+    nameRender: React.ComponentType<Omit<ITriggerConfigProps, 'sampleData'>>;
+    createDefaultConfig?: () => AnyObject;
+    migrator?: IConfigMigrator;
+}
+export interface ITrigger {
+    id: string;
+    schemaRef: string;
+    triggerData: PluginStorage;
+}
+/**
+ * A readonly snapshot of a trigger
+ */
+export interface ITriggerSnapshot<TConfig> {
+    id: string;
+    schemaRef: string;
+    config: TConfig;
+}
+export interface IVizTriggerManager {
+    getTriggerSchemaList(): ITriggerSchema[];
+    getTriggerList(): Promise<ITrigger[]>;
+    removeTrigger(triggerId: string): Promise<void>;
+    createOrGetTrigger(id: string, schema: ITriggerSchema): Promise<ITrigger>;
+    retrieveTrigger(id: string): Promise<ITrigger | undefined>;
+    watchTriggerSnapshotList(callback: (triggerList: ITriggerSnapshot<AnyObject>[]) => void): () => void;
+    needMigration(): Promise<boolean>;
+    runMigration(): Promise<void>;
+}
+export interface IDashboardOperationSchema {
+    id: string;
+    displayName: string;
+    configRender: React.ComponentType<IOperationConfigProps>;
+    run: (payload: Record<string, unknown>, operation: IDashboardOperation) => Promise<void>;
+    migrator?: IConfigMigrator;
+    createDefaultConfig?: () => AnyObject;
+}
+export interface IDashboardOperation {
+    id: string;
+    schemaRef: string;
+    operationData: PluginStorage;
+}
+export interface IVizOperationManager {
+    getOperationSchemaList(): IDashboardOperationSchema[];
+    getOperationList(): Promise<IDashboardOperation[]>;
+    removeOperation(operationId: string): Promise<void>;
+    createOrGetOperation(id: string, schema: IDashboardOperationSchema): Promise<IDashboardOperation>;
+    runOperation(operationId: string, payload: Record<string, unknown>): Promise<void>;
+    retrieveTrigger(operationId: string): Promise<IDashboardOperation | undefined>;
+    runMigration(): Promise<void>;
+    needMigration(): Promise<boolean>;
+}
+export interface IVizInteraction {
+    id: string;
+    triggerRef: string;
+    operationRef: string;
+}
+export interface IVizInteractionManager {
+    triggerManager: IVizTriggerManager;
+    operationManager: IVizOperationManager;
+    getInteractionList(): Promise<IVizInteraction[]>;
+    addInteraction(trigger: ITrigger, operation: IDashboardOperation): Promise<void>;
+    removeInteraction(interactionId: string): Promise<void>;
+    runInteraction(triggerId: string, payload: Record<string, unknown>): Promise<void>;
+}
+export interface IValueStep {
+    from: number;
+    to: number;
+}
+export interface IColorInterpolationConfig {
+    steps: IValueStep[];
+    interpolation: string;
+}
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,4 @@
+export declare type AnyObject = Record<string, $TSFixMe>;
+export declare type Ready<T, TK extends keyof T> = T & {
+    [P in TK]-?: NonNullable<T[P]>;
+};

package/dist/utils/aggregation.d.ts

@@ -0,0 +1,12 @@
+import { AnyObject } from '~/types';
+export declare type AggregationType = {
+    type: 'none' | 'sum' | 'mean' | 'median' | 'max' | 'min' | 'CV' | 'std';
+    config: Record<$TSFixMe, never>;
+} | {
+    type: 'quantile';
+    config: {
+        p: number;
+    };
+};
+export declare const DefaultAggregation: AggregationType;
+export declare function aggregateValue(data: AnyObject[], data_field: string, aggregation: AggregationType): number | number[] | "N/A" | null;

package/dist/utils/color-mapping.d.ts

@@ -0,0 +1,9 @@
+export interface InterpolateColorOption {
+    valueRange: number[];
+    colorRange: string[];
+}
+export declare class InterpolateColor {
+    mapper: (v: number) => string;
+    constructor({ valueRange, colorRange }: InterpolateColorOption);
+    getColor(value: number): string;
+}

package/dist/utils/download.d.ts

@@ -0,0 +1,7 @@
+export declare function downloadCSV(id: string, csv: string): void;
+export declare function downloadJSON(name: string, json: string): void;
+export declare function downloadDataListAsZip(idDataList: Array<{
+    id: string;
+    data: TVizData;
+}>): void;
+export declare function makeCSV(data: TVizData): string;

package/dist/utils/error-boundary.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+declare type PropType = {
+    children: React.ReactNode;
+};
+declare type StateType = {
+    error: null | $TSFixMe;
+};
+export declare class ErrorBoundary extends React.Component<PropType, StateType> {
+    constructor(props: PropType);
+    componentDidCatch(error: $TSFixMe): void;
+    render(): string | number | boolean | JSX.Element | React.ReactFragment | null | undefined;
+}
+export {};

package/dist/utils/function-utils.d.ts

@@ -0,0 +1,15 @@
+import CryptoJS from 'crypto-js';
+import dayjs from 'dayjs';
+import lodash from 'lodash';
+import numbro from 'numbro';
+import * as d3Array from 'd3-array';
+import * as mathjs from 'mathjs';
+export declare const functionUtils: {
+    CryptoJS: typeof CryptoJS;
+    d3Array: typeof d3Array;
+    dayjs: typeof dayjs;
+    lodash: lodash.LoDashStatic;
+    numbro: typeof numbro;
+    mathjs: mathjs.MathJsStatic;
+};
+export declare const FunctionUtilsDescription: string;

package/dist/utils/http-query.d.ts

@@ -0,0 +1,17 @@
+import { AxiosRequestConfig } from 'axios';
+import { IDataSource } from '~/api-caller/types';
+import { ContextInfoType, FilterValuesType } from '..';
+export declare function buildHTTPRequest(pre_process: string, params: {
+    context: Record<string, any>;
+    filters: Record<string, any>;
+}): AxiosRequestConfig<any>;
+export declare function getHTTPReqeustBuilderParams(real_context: ContextInfoType, mock_context: Record<string, $TSFixMe>, filterValues: FilterValuesType): {
+    context: {
+        [x: string]: any;
+    };
+    filters: FilterValuesType;
+};
+export declare function explainHTTPRequest(pre_process: string, context: ContextInfoType, mock_context: Record<string, $TSFixMe>, filterValues: FilterValuesType): AxiosRequestConfig<any>;
+export declare function preProcessWithDataSource(datasource: IDataSource, config: AxiosRequestConfig): any;
+export declare function postProcessWithDataSource(datasource: IDataSource, res: any): any;
+export declare function postProcessWithQuery(post_process: TFunctionString, res: any): any;

package/dist/utils/shallow-to-js.d.ts

@@ -0,0 +1 @@
+export declare const shallowToJS: <T>(obj: T) => T;

package/dist/utils/sql.d.ts

@@ -0,0 +1,18 @@
+import { FilterValuesType } from '../model';
+import { ContextInfoType } from '../model/context';
+import { SQLSnippetModelInstance } from '../model/sql-snippets';
+export declare function explainSQLSnippet(snippet: string, context: ContextInfoType, mock_context: Record<string, $TSFixMe>, filterValues: FilterValuesType): any;
+export declare function formatSQL(sql: string, params?: Record<string, $TSFixMe>): any;
+export declare function getSQLParams(real_context: ContextInfoType, mock_context: Record<string, $TSFixMe>, sqlSnippets: SQLSnippetModelInstance[], filterValues: FilterValuesType): {
+    context: {
+        [x: string]: any;
+    };
+    filters: FilterValuesType;
+    sql_snippets: Record<string, any>;
+};
+export declare function explainSQL(sql: string, context: ContextInfoType, mock_context: Record<string, $TSFixMe>, sqlSnippets: SQLSnippetModelInstance[], filterValues: FilterValuesType): any;
+export declare function preProcessSQLQuery({ sql, pre_process }: {
+    sql: string;
+    pre_process: TFunctionString;
+}): any;
+export declare function postProcessSQLQuery(post_process: TFunctionString, data: any): any;

package/dist/utils/template/editor/index.d.ts

@@ -0,0 +1,3 @@
+export * from './template-input';
+export * from './utils';
+export * from './variable-field';

package/dist/utils/template/editor/template-input.d.ts

@@ -0,0 +1,8 @@
+import { TextInputProps } from '@mantine/core';
+import { ChangeEventHandler } from 'react';
+interface ITemplateInput extends Omit<TextInputProps, 'value' | 'onChange'> {
+    value: string;
+    onChange: ChangeEventHandler<HTMLInputElement>;
+}
+export declare const TemplateInput: import("react").ForwardRefExoticComponent<ITemplateInput & import("react").RefAttributes<unknown>>;
+export {};

package/dist/utils/template/editor/utils.d.ts

@@ -0,0 +1,2 @@
+import { ITemplateVariable } from '../types';
+export declare function getANewVariable(): ITemplateVariable;

package/dist/utils/template/editor/variable-field.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ITemplateVariable } from '../types';
+interface ITemplateVariableField {
+    value: ITemplateVariable;
+    onChange: (v: ITemplateVariable) => void;
+    data: TVizData;
+    withStyle?: boolean;
+}
+export declare const TemplateVariableField: React.ForwardRefExoticComponent<ITemplateVariableField & React.RefAttributes<unknown>>;
+export {};

package/dist/utils/template/editor/variable-style.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ITemplateVariable } from '../types';
+interface ITemplateVariableStyleField {
+    value: ITemplateVariable;
+    onChange: (v: ITemplateVariable) => void;
+}
+export declare const TemplateVariableStyleField: React.ForwardRefExoticComponent<ITemplateVariableStyleField & React.RefAttributes<unknown>>;
+export {};

package/dist/utils/template/index.d.ts

@@ -0,0 +1,4 @@
+export * from './editor';
+export * from './render';
+export * from './types';
+export * from './utils';

package/dist/utils/template/render/index.d.ts

@@ -0,0 +1,2 @@
+export * from './render-jsx';
+export * from './render-string';