courthive-components 1.0.4 → 1.1.1

package/dist/components/modal/compositionEditorModal.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Composition Editor Modal — configure PDF header/footer layouts.
+ *
+ * Opens a modal with two tabs (via menu): Header Config and Footer Config.
+ * Each tab provides form controls for selecting layouts and entering field values.
+ * Returns the composed HeaderConfig + FooterConfig for pdf-factory.
+ */
+export interface HeaderConfig {
+    layout: string;
+    tournamentName: string;
+    subtitle?: string;
+    startDate?: string;
+    endDate?: string;
+    location?: string;
+    city?: string;
+    country?: string;
+    surface?: string;
+    prizeMoney?: string;
+    currency?: string;
+    supervisor?: string;
+    grade?: string;
+    sectionLabel?: string;
+    organizer?: string;
+    chiefUmpire?: string;
+    tournamentId?: string;
+}
+export interface FooterConfig {
+    layout: string;
+    showPageNumbers?: boolean;
+    showTimestamp?: boolean;
+    releaseDate?: string;
+    drawCeremonyDate?: string;
+    notes?: string[];
+}
+export interface CompositionEditorResult {
+    header: HeaderConfig;
+    footer: FooterConfig;
+    preset?: string;
+}
+export interface CompositionEditorOptions {
+    initialPreset?: string;
+    initialHeader?: Partial<HeaderConfig>;
+    initialFooter?: Partial<FooterConfig>;
+    onApply?: (result: CompositionEditorResult) => void;
+}
+export declare function openCompositionEditorModal(options?: CompositionEditorOptions): any;

package/dist/components/modal/generateTeamsModal.d.ts

@@ -0,0 +1,26 @@
+export interface GenerateTeamsConfig {
+    callback?: (participants: any[]) => void;
+    consideredDate?: string;
+    title?: string;
+    /** Builtin + user tieFormats for team size inference */
+    tieFormats?: {
+        label: string;
+        value: string;
+        tieFormat: any;
+    }[];
+    /** Custom labels for form fields and buttons */
+    labels?: {
+        gender?: string;
+        teamsCount?: string;
+        tieFormatTemplate?: string;
+        manualTeamSize?: string;
+        playersPerTeam?: string;
+        countries?: string;
+        cancel?: string;
+        generate?: string;
+        genderAny?: string;
+        genderFemale?: string;
+        genderMale?: string;
+    };
+}
+export declare function getGenerateTeamsModal(config?: GenerateTeamsConfig): void;

package/dist/components/modal/mockParticipants.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Configuration for mock participants generation
+ */
+export interface MockParticipantsConfig {
+    /** Callback invoked when participants are generated */
+    callback?: (participants: any[]) => void;
+    /** Tournament end date for birthdate calculation (ISO format: YYYY-MM-DD) */
+    consideredDate?: string;
+    /** Custom title for the modal */
+    title?: string;
+    /** Custom labels for form fields */
+    labels?: {
+        gender?: string;
+        count?: string;
+        ageRange?: string;
+        minAge?: string;
+        maxAge?: string;
+        ratings?: string;
+        countries?: string;
+        role?: string;
+        cancel?: string;
+        generate?: string;
+        genderAny?: string;
+        genderFemale?: string;
+        genderMale?: string;
+        /** @deprecated Use ratings label instead */
+        wtn?: string;
+        /** @deprecated Use ratings label instead */
+        utr?: string;
+    };
+    /** Default values for form fields */
+    defaults?: {
+        gender?: string;
+        participantsCount?: number;
+        participantRole?: string;
+        ageMin?: number;
+        ageMax?: number;
+        nationalityCodesCount?: number;
+        /** Array of rating type names to pre-select (e.g., ['WTN', 'UTR', 'DUPR']) */
+        ratings?: string[];
+        /** @deprecated Use ratings: ['WTN'] instead */
+        wtnRating?: boolean;
+        /** @deprecated Use ratings: ['UTR'] instead */
+        utrRating?: boolean;
+    };
+    /** Available participant role options. If not provided, only COMPETITOR is used. */
+    roleOptions?: {
+        label: string;
+        value: string;
+    }[];
+}
+/**
+ * Opens a modal for generating mock participants with configurable options.
+ *
+ * Features:
+ * - Gender selection (Any/Male/Female)
+ * - Participant count (8-256)
+ * - Age range with automatic validation (ageMax >= ageMin)
+ * - Number of countries to limit nationality diversity
+ * - Optional WTN/UTR ratings
+ * - Birthdate generation based on consideredDate and age range
+ *
+ * @param config - Configuration options
+ * @returns void
+ *
+ * @example
+ * // Basic usage
+ * getMockParticipantsModal({
+ *   callback: (participants) => {
+ *     console.log('Generated participants:', participants);
+ *     // Add participants to tournament
+ *   }
+ * });
+ *
+ * @example
+ * // With consideredDate and defaults
+ * getMockParticipantsModal({
+ *   consideredDate: '2024-12-31',
+ *   callback: (participants) => {
+ *     // Add participants to tournament
+ *   },
+ *   defaults: {
+ *     participantsCount: 64,
+ *     ageMin: 10,
+ *     ageMax: 18,
+ *     nationalityCodesCount: 10,
+ *     wtnRating: true
+ *   }
+ * });
+ */
+export declare function getMockParticipantsModal(config?: MockParticipantsConfig): void;

package/dist/components/modal/scheduleCellConfigModal.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Schedule Cell Configurator Modal — select what info appears in OOP grid cells.
+ *
+ * Provides checkboxes for each field that can appear in a schedule cell:
+ * participant names, match number, event/round, nationality, seeds,
+ * scheduled time, format code, score.
+ *
+ * Returns a CellConfig object consumed by pdf-factory's scheduleV2 renderer.
+ */
+export interface ScheduleCellDisplayConfig {
+    showParticipantNames: boolean;
+    showNationality: boolean;
+    showSeedings: boolean;
+    showMatchNumber: boolean;
+    showEventRound: boolean;
+    showScheduledTime: boolean;
+    showMatchFormat: boolean;
+    showScore: boolean;
+    nameFormat: 'full' | 'abbreviated' | 'lastOnly';
+    cellStyle: 'detailed' | 'compact';
+}
+export interface ScheduleCellConfigOptions {
+    initial?: Partial<ScheduleCellDisplayConfig>;
+    onApply?: (config: ScheduleCellDisplayConfig) => void;
+}
+export declare function openScheduleCellConfigModal(options?: ScheduleCellConfigOptions): {
+    setContent: ({ content: newContent, config }: {
+        content?: string | HTMLElement | ((container: HTMLElement) => any);
+        config?: import('../../types').ModalConfig;
+    }) => void;
+    setButtons: ({ buttons, config }: {
+        buttons: import('../../types').ModalButton[];
+        config?: import('../../types').ModalConfig;
+    }) => void;
+    update: ({ content: newContent, buttons, title, config: newConfig, onClose }: {
+        content?: string | HTMLElement | ((container: HTMLElement) => any);
+        buttons?: import('../../types').ModalButton[];
+        title?: string;
+        config?: import('../../types').ModalConfig;
+        onClose?: (params: {
+            content?: any;
+        }) => void;
+    }) => void;
+};

package/dist/components/modal/selectItem.d.ts

@@ -0,0 +1,24 @@
+export interface SelectItemParams {
+    title: string;
+    placeholder?: string;
+    options: SelectItemOption[];
+    selectionLimit?: number;
+    /** Factory to create a selection table. If not provided, a simple list is used. */
+    createTable?: (config: {
+        anchorId: string;
+        data: any[];
+        selectionLimit?: number;
+        onSelected: (value: any[]) => void;
+    }) => {
+        table: any;
+        destroy?: () => void;
+    };
+    /** Factory to create a search filter function for the table. */
+    createFilter?: (table: any) => (value: string) => void;
+}
+export interface SelectItemOption {
+    label: string;
+    onClick?: () => void;
+    [key: string]: any;
+}
+export declare function selectItem(params: SelectItemParams): void;

package/dist/components/notes-toolbar/notesToolbar.d.ts

@@ -0,0 +1,20 @@
+export interface NotesToolbarOptions {
+    onBold?: () => void;
+    onItalic?: () => void;
+    onUnderline?: () => void;
+    onStrike?: () => void;
+    onHeading?: (level: number | false) => void;
+    onColor?: (color: string) => void;
+    onBackground?: (color: string) => void;
+    onBulletList?: () => void;
+    onOrderedList?: () => void;
+    onAlign?: (align: string) => void;
+    onBlockquote?: () => void;
+    onCodeBlock?: () => void;
+    onLink?: (url: string) => void;
+    onVideo?: (url: string) => void;
+    onClearFormatting?: () => void;
+}
+export declare function notesToolbar(options?: NotesToolbarOptions): HTMLElement;
+export declare function updateToolbarState(toolbar: HTMLElement, activeMap: Record<string, boolean>): void;
+export declare function updateHeadingSelect(toolbar: HTMLElement, level: number | false): void;

package/dist/components/policy-catalog/controller/policyCatalogControl.d.ts

@@ -0,0 +1,18 @@
+import { PolicyCatalogStore } from '../engine/policyCatalogStore';
+import { PolicyCatalogConfig } from '../types';
+export declare class PolicyCatalogControl {
+    private readonly store;
+    private readonly layout;
+    private readonly editorShell;
+    private readonly unsubscribe;
+    private currentEditor;
+    private container;
+    constructor(config: PolicyCatalogConfig);
+    render(container: HTMLElement): void;
+    destroy(): void;
+    getStore(): PolicyCatalogStore;
+    private handleSelectPolicy;
+    private mountEditorForSelection;
+    private syncEditorFromStore;
+    private destroyCurrentEditor;
+}

package/dist/components/policy-catalog/domain/catalogProjections.d.ts

@@ -0,0 +1,11 @@
+import { PolicyCatalogItem, CatalogGroupBy } from '../types';
+/**
+ * Filter catalog items by search query.
+ * Matches against name, policyType label, description, and source.
+ */
+export declare function filterPolicyCatalog(catalog: PolicyCatalogItem[], searchQuery: string): PolicyCatalogItem[];
+/**
+ * Group catalog items by type or source.
+ * Returns a Map with stable group ordering.
+ */
+export declare function groupPolicyCatalog(catalog: PolicyCatalogItem[], groupBy: CatalogGroupBy): Map<string, PolicyCatalogItem[]>;

package/dist/components/policy-catalog/domain/policyDefaults.d.ts

@@ -0,0 +1,26 @@
+import { PolicyTypeMeta, PolicyTypeGroup } from '../types';
+export declare const POLICY_TYPE_SCHEDULING = "scheduling";
+export declare const POLICY_TYPE_SCORING = "scoring";
+export declare const POLICY_TYPE_SEEDING = "seeding";
+export declare const POLICY_TYPE_DRAWS = "draws";
+export declare const POLICY_TYPE_AVOIDANCE = "avoidance";
+export declare const POLICY_TYPE_FEED_IN = "feedIn";
+export declare const POLICY_TYPE_PROGRESSION = "progression";
+export declare const POLICY_TYPE_ROUND_NAMING = "roundNaming";
+export declare const POLICY_TYPE_POSITION_ACTIONS = "positionActions";
+export declare const POLICY_TYPE_MATCHUP_ACTIONS = "matchUpActions";
+export declare const POLICY_TYPE_ROUND_ROBIN_TALLY = "roundRobinTally";
+export declare const POLICY_TYPE_RANKING_POINTS = "rankingPoints";
+export declare const POLICY_TYPE_COMPETITIVE_BANDS = "competitiveBands";
+export declare const POLICY_TYPE_VOLUNTARY_CONSOLATION = "voluntaryConsolation";
+export declare const POLICY_TYPE_PARTICIPANT = "participant";
+export declare const POLICY_TYPE_DISPLAY = "display";
+export declare const POLICY_TYPE_AUDIT = "audit";
+export declare const POLICY_TYPE_PRIVACY = "participant";
+export declare const POLICY_TYPE_METADATA: PolicyTypeMeta[];
+/** Lookup metadata by policyType string */
+export declare function getPolicyTypeMeta(policyType: string): PolicyTypeMeta | undefined;
+/** Get empty policy data for a given policy type */
+export declare function getEmptyPolicyData(policyType: string): Record<string, unknown>;
+/** Get all unique group names in display order */
+export declare const POLICY_TYPE_GROUPS: PolicyTypeGroup[];

package/dist/components/policy-catalog/domain/utils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Policy Catalog — Domain Utilities
+ */
+export declare function deepClone<T>(obj: T): T;

package/dist/components/policy-catalog/editors/ranking/domain/emptyRankingPolicy.d.ts

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

package/dist/components/policy-catalog/editors/ranking/domain/rankingProjections.d.ts

@@ -0,0 +1,32 @@
+import { AwardProfileData, TableLayout } from '../types';
+export declare function positionToRoundLabel(position: number): string;
+/**
+ * Analyze a profile's finishingPositionRanges to determine the best table layout.
+ * Examines all values to find the common shape.
+ */
+export declare function analyzePositionValueShape(ranges: Record<string, any> | undefined): TableLayout;
+/**
+ * Resolve a PositionValue for display in a specific context.
+ * Returns the numeric value or undefined if not applicable.
+ */
+export declare function resolvePositionValue(value: any, context?: {
+    level?: number;
+    flight?: number;
+    drawSize?: number;
+}): number | undefined;
+/**
+ * Generate a one-line summary for a collapsed profile card.
+ */
+export declare function profileSummaryText(profile: AwardProfileData): string;
+export interface ScopeBadge {
+    label: string;
+    intent: string;
+}
+/**
+ * Extract displayable scope badges from an award profile.
+ */
+export declare function getProfileScopeBadges(profile: AwardProfileData): ScopeBadge[];
+/**
+ * Format a number for display in a points table cell.
+ */
+export declare function formatPointValue(value: number | undefined): string;

package/dist/components/policy-catalog/editors/ranking/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Ranking Points Editor — Public API
+ */
+export { RankingPointsEditorControl, createRankingPointsEditor } from './rankingPointsEditorControl';
+export { RankingPointsEditorStore } from './rankingPointsEditorStore';
+export { buildRankingPointsEditorPanel } from './rankingPointsEditorPanel';
+export { analyzePositionValueShape, resolvePositionValue, positionToRoundLabel, formatPointValue, getProfileScopeBadges, profileSummaryText } from './domain/rankingProjections';
+export { emptyRankingPolicy } from './domain/emptyRankingPolicy';
+export type { RankingPolicyData, RankingPointsEditorState, RankingEditorSection, RankingPointsEditorChangeListener, RankingPointsEditorConfig, AwardProfileData, QualityWinProfileData, AggregationRulesData, TableLayout } from './types';

package/dist/components/policy-catalog/editors/ranking/rankingPointsEditorControl.d.ts

@@ -0,0 +1,27 @@
+import { RankingPointsEditorStore } from './rankingPointsEditorStore';
+import { RankingPolicyData, RankingPointsEditorConfig } from './types';
+import { PolicyEditorInstance as CatalogEditorInstance } from '../../types';
+export declare class RankingPointsEditorControl {
+    private readonly store;
+    private readonly panel;
+    private readonly unsubscribe;
+    private container;
+    constructor(config: RankingPointsEditorConfig);
+    render(container: HTMLElement): void;
+    destroy(): void;
+    getData(): RankingPolicyData;
+    setData(data: RankingPolicyData): void;
+    getStore(): RankingPointsEditorStore;
+    /**
+     * Create as a PolicyEditorInstance for embedding in the catalog editor shell.
+     */
+    static createEditorInstance(config: {
+        initialData: Record<string, unknown>;
+        onChange: (data: Record<string, unknown>) => void;
+        readonly?: boolean;
+    }): CatalogEditorInstance;
+}
+/**
+ * Convenience factory for standalone use.
+ */
+export declare function createRankingPointsEditor(config: RankingPointsEditorConfig, container: HTMLElement): RankingPointsEditorControl;

package/dist/components/policy-catalog/editors/ranking/rankingPointsEditorPanel.d.ts

@@ -0,0 +1,8 @@
+import { RankingPointsEditorStore } from './rankingPointsEditorStore';
+import { RankingPointsEditorState, RankingPointsEditorConfig } from './types';
+interface PanelResult {
+    element: HTMLElement;
+    update: (state: RankingPointsEditorState) => void;
+}
+export declare function buildRankingPointsEditorPanel(store: RankingPointsEditorStore, _config: RankingPointsEditorConfig): PanelResult;
+export {};

package/dist/components/policy-catalog/editors/ranking/rankingPointsEditorStore.d.ts

@@ -0,0 +1,53 @@
+import { RankingPolicyData, RankingPointsEditorState, RankingEditorSection, RankingPointsEditorChangeListener, RankingPointsEditorConfig } from './types';
+export declare class RankingPointsEditorStore {
+    private state;
+    private readonly listeners;
+    private readonly config;
+    constructor(config: RankingPointsEditorConfig);
+    getState(): RankingPointsEditorState;
+    getData(): RankingPolicyData;
+    setData(data: RankingPolicyData): void;
+    toggleSection(sectionId: RankingEditorSection): void;
+    toggleProfile(index: number): void;
+    setProfileFilter(filter: string): void;
+    setPolicyName(name: string): void;
+    setPolicyVersion(version: string): void;
+    setValidDateRange(field: 'startDate' | 'endDate', value: string): void;
+    setGlobalFlag(key: 'requireWinForPoints' | 'requireWinFirstRound', value: boolean): void;
+    setDoublesAttribution(value: string): void;
+    setCategoryResolution(value: string): void;
+    addProfile(): void;
+    removeProfile(index: number): void;
+    duplicateProfile(index: number): void;
+    moveProfile(fromIndex: number, toIndex: number): void;
+    setProfileName(index: number, name: string): void;
+    setProfileFlag(index: number, key: 'requireWinForPoints' | 'requireWinFirstRound', value: boolean | undefined): void;
+    setFlatPositionPoints(profileIndex: number, position: number, value: number): void;
+    addPositionRow(profileIndex: number, position: number): void;
+    removePositionRow(profileIndex: number, position: number): void;
+    setPointsPerWin(profileIndex: number, value: number | undefined): void;
+    addBonusPoint(profileIndex: number): void;
+    removeBonusPoint(profileIndex: number, bonusIndex: number): void;
+    setBonusPointPositions(profileIndex: number, bonusIndex: number, positions: number[]): void;
+    setBonusPointValue(profileIndex: number, bonusIndex: number, value: number): void;
+    setLevelPositionPoints(profileIndex: number, position: number, level: number, value: number): void;
+    addLevel(profileIndex: number, level: number): void;
+    removeLevel(profileIndex: number, level: number): void;
+    setProfileScope(profileIndex: number, field: string, values: any[]): void;
+    setProfileField(profileIndex: number, field: string, value: any): void;
+    addQualityWinProfile(): void;
+    removeQualityWinProfile(index: number): void;
+    setQualityWinField(index: number, field: string, value: any): void;
+    addQualityWinRange(profileIndex: number): void;
+    removeQualityWinRange(profileIndex: number, rangeIndex: number): void;
+    setQualityWinRange(profileIndex: number, rangeIndex: number, field: 'rankRange' | 'value', value: any): void;
+    setAggregationField(field: string, value: any): void;
+    addTiebreakCriterion(criterion: string): void;
+    removeTiebreakCriterion(index: number): void;
+    addCountingBucket(): void;
+    removeCountingBucket(index: number): void;
+    setCountingBucketField(index: number, field: string, value: any): void;
+    subscribe(listener: RankingPointsEditorChangeListener): () => void;
+    private commitDraft;
+    private emit;
+}

package/dist/components/policy-catalog/editors/ranking/sections/aggregationSection.d.ts

@@ -0,0 +1,6 @@
+import { RankingPointsEditorStore } from '../rankingPointsEditorStore';
+import { RankingPointsEditorState } from '../types';
+export declare function buildAggregationSection(store: RankingPointsEditorStore): {
+    element: HTMLElement;
+    update(state: RankingPointsEditorState): void;
+};

package/dist/components/policy-catalog/editors/ranking/sections/bonusPointsRow.d.ts

@@ -0,0 +1,6 @@
+import { RankingPointsEditorState } from '../types';
+import { RankingPointsEditorStore } from '../rankingPointsEditorStore';
+export declare function buildBonusPointsRow(store: RankingPointsEditorStore, profileIndex: number): {
+    element: HTMLElement;
+    update(state: RankingPointsEditorState): void;
+};

package/dist/components/policy-catalog/editors/ranking/sections/metadataSection.d.ts

@@ -0,0 +1,6 @@
+import { RankingPointsEditorState } from '../types';
+import { RankingPointsEditorStore } from '../rankingPointsEditorStore';
+export declare function buildMetadataSection(store: RankingPointsEditorStore): {
+    element: HTMLElement;
+    update(state: RankingPointsEditorState): void;
+};

package/dist/components/policy-catalog/editors/ranking/sections/perWinPointsRow.d.ts

@@ -0,0 +1,6 @@
+import { RankingPointsEditorState } from '../types';
+import { RankingPointsEditorStore } from '../rankingPointsEditorStore';
+export declare function buildPerWinPointsRow(store: RankingPointsEditorStore, profileIndex: number): {
+    element: HTMLElement;
+    update(state: RankingPointsEditorState): void;
+};

package/dist/components/policy-catalog/editors/ranking/sections/positionPointsTable.d.ts

@@ -0,0 +1,6 @@
+import { RankingPointsEditorState } from '../types';
+import { RankingPointsEditorStore } from '../rankingPointsEditorStore';
+export declare function buildPositionPointsTable(store: RankingPointsEditorStore, profileIndex: number): {
+    element: HTMLElement;
+    update(state: RankingPointsEditorState): void;
+};

package/dist/components/policy-catalog/editors/ranking/sections/profileCard.d.ts

@@ -0,0 +1,6 @@
+import { RankingPointsEditorState } from '../types';
+import { RankingPointsEditorStore } from '../rankingPointsEditorStore';
+export declare function buildProfileCard(store: RankingPointsEditorStore, profileIndex: number): {
+    element: HTMLElement;
+    update(state: RankingPointsEditorState): void;
+};

package/dist/components/policy-catalog/editors/ranking/sections/qualityWinSection.d.ts

@@ -0,0 +1,6 @@
+import { RankingPointsEditorState } from '../types';
+import { RankingPointsEditorStore } from '../rankingPointsEditorStore';
+export declare function buildQualityWinSection(store: RankingPointsEditorStore): {
+    element: HTMLElement;
+    update(state: RankingPointsEditorState): void;
+};

package/dist/components/policy-catalog/editors/ranking/sections/scopeBadges.d.ts

@@ -0,0 +1,2 @@
+import { AwardProfileData } from '../types';
+export declare function buildScopeBadges(profile: AwardProfileData): HTMLElement;

package/dist/components/policy-catalog/editors/ranking/sections/scopeEditor.d.ts

@@ -0,0 +1,6 @@
+import { RankingPointsEditorState } from '../types';
+import { RankingPointsEditorStore } from '../rankingPointsEditorStore';
+export declare function buildScopeEditor(store: RankingPointsEditorStore, profileIndex: number): {
+    element: HTMLElement;
+    update(state: RankingPointsEditorState): void;
+};

package/dist/components/policy-catalog/editors/ranking/styles.d.ts

@@ -0,0 +1,25 @@
+export declare const reSectionStyle: () => string;
+export declare const reSectionHeaderStyle: () => string;
+export declare const reSectionChevronStyle: () => string;
+export declare const reSectionCountStyle: () => string;
+export declare const reSectionBodyStyle: () => string;
+export declare const reFieldRowStyle: () => string;
+export declare const reFieldLabelStyle: () => string;
+export declare const reFieldInputStyle: () => string;
+export declare const reFieldInputTextStyle: () => string;
+export declare const reFieldInputNumberStyle: () => string;
+export declare const reFieldInputDateStyle: () => string;
+export declare const reFieldSelectStyle: () => string;
+export declare const reCheckboxRowStyle: () => string;
+export declare const rePointsInputStyle: () => string;
+export declare const reProfileCardStyle: () => string;
+export declare const reProfileHeaderStyle: () => string;
+export declare const reProfileNameInputStyle: () => string;
+export declare const reProfileBodyStyle: () => string;
+export declare const reProfileActionsStyle: () => string;
+export declare const reIconBtnStyle: () => string;
+export declare const reIconBtnDangerStyle: () => string;
+export declare const reAddBtnStyle: () => string;
+export declare const reRemoveBtnStyle: () => string;
+export declare const reEmptyStyle: () => string;
+export declare const reEditorStyle: () => string;