courthive-components 1.0.4 → 1.1.1

package/dist/components/forms/createMultiSelect.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Custom multi-select dropdown with tag chips and checkbox panel.
+ *
+ * Visual structure:
+ * ┌──────────────────────────────────────┐
+ * │ WTN ×  UTR ×                      ▼ │  ← trigger: tags + chevron
+ * ├──────────────────────────────────────┤
+ * │ ✓ WTN                               │  ← dropdown (checkboxes)
+ * │ ✓ UTR                               │
+ * │   DUPR                              │
+ * └──────────────────────────────────────┘
+ *
+ * All colors use --chc-* CSS variables for automatic dark-mode support.
+ */
+interface MultiSelectOption {
+    label: string;
+    value: string;
+    selected?: boolean;
+    disabled?: boolean;
+}
+interface MultiSelectItem {
+    options: MultiSelectOption[];
+    onChange?: (e: Event, item: any) => void;
+    id?: string;
+}
+type MultiSelectElement = HTMLDivElement & {
+    selectedValues: string[];
+    value: string;
+};
+export declare function createMultiSelect(item: MultiSelectItem): {
+    container: HTMLDivElement;
+    element: MultiSelectElement;
+};
+export {};

package/dist/components/forms/renderButtons.d.ts

@@ -0,0 +1,3 @@
+export declare function renderButtons(target: HTMLElement, buttons: any[], close?: () => void): {
+    elements: Record<string, HTMLElement>;
+};

package/dist/components/forms/renderField.d.ts

@@ -0,0 +1,7 @@
+export declare function renderOptions(select: HTMLSelectElement, item: any): void;
+export declare function renderField(item: any): {
+    field: HTMLDivElement;
+    inputElement?: HTMLDivElement | HTMLSelectElement;
+    datepicker?: any;
+    subFields?: any[];
+};

package/dist/components/forms/renderForm.d.ts

@@ -0,0 +1 @@
+export declare function renderForm(elem: HTMLElement, items: any[], relationships?: any[]): any;

package/dist/components/forms/renderMenu.d.ts

@@ -0,0 +1,3 @@
+export declare function renderMenu(elem: HTMLElement, menu: any[], close?: () => void): {
+    focusElement?: HTMLElement;
+};

package/dist/components/forms/renderValidator.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Validate input field and update UI with success/error styling.
+ *
+ * OVERVIEW:
+ * Runs a validation function on input value and updates the input field and help text
+ * with appropriate styling (success=green, error=red) and error messages. Used by
+ * renderField to provide real-time validation feedback.
+ *
+ * PARAMETERS:
+ * @param item - Field configuration object containing error message
+ * @param e - Event object with target.value containing input value
+ * @param input - Input element to add success/error classes to
+ * @param help - Help text element to display error message
+ * @param fx - Validation function that returns true if valid, false if invalid
+ *
+ * ============================================================================
+ * BEHAVIOR
+ * ============================================================================
+ *
+ * VALIDATION FLOW:
+ * 1. Extract value from e.target.value
+ * 2. Call validation function fx(value)
+ * 3. If invalid (fx returns false):
+ *    - Set help text to item.error or 'Invalid'
+ *    - Remove 'is-success' class from input
+ *    - Add 'is-danger' class to input (red border)
+ *    - Add 'is-danger' class to help (red text)
+ * 4. If valid (fx returns true):
+ *    - Clear help text
+ *    - Remove 'is-danger' classes
+ *    - Add 'is-success' class to input (green border)
+ *
+ * VISUAL FEEDBACK:
+ * - Invalid: Red border on input + red error message below
+ * - Valid: Green border on input + no message
+ * - Neutral: No border color + no message (before first input)
+ *
+ * ============================================================================
+ * VALIDATION FUNCTIONS
+ * ============================================================================
+ *
+ * Validation functions should:
+ * - Accept a string value parameter
+ * - Return true if valid, false if invalid
+ * - Be synchronous (no async validation)
+ *
+ * COMMON VALIDATORS:
+ * - nameValidator(minLength) - checks minimum character length
+ * - emailValidator() - validates email format
+ * - passwordValidator() - checks password requirements
+ * - numericRange(min, max) - validates number is in range
+ * - Custom: (value) => value.length > 0 && value.includes('@')
+ *
+ * ============================================================================
+ * USAGE NOTES
+ * ============================================================================
+ *
+ * TYPICAL USAGE:
+ * - Called automatically by renderField when validator property is set
+ * - Attached to 'input' event for real-time validation
+ * - Rarely called directly - use via renderField configuration
+ *
+ * ERROR MESSAGES:
+ * - Set via item.error property in field configuration
+ * - Default message is 'Invalid' if item.error not provided
+ * - Should be clear and actionable (e.g., "Minimum 5 characters")
+ *
+ * STYLING:
+ * - Uses CSS classes: is-success, is-danger
+ * - Input field gets colored border
+ * - Help text appears below input with matching color
+ *
+ * ============================================================================
+ * EXAMPLE USAGE
+ * ============================================================================
+ *
+ * @example
+ * // Automatic usage via renderField
+ * const field = renderField({
+ *   label: 'Username',
+ *   field: 'username',
+ *   validator: (value) => value.length >= 5,
+ *   error: 'Username must be at least 5 characters'
+ * });
+ * // validator() is called automatically on input event
+ *
+ * @example
+ * // Direct usage (rare)
+ * const input = document.getElementById('email');
+ * const help = document.getElementById('email-help');
+ * const item = { error: 'Invalid email format' };
+ * const emailValidator = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+ *
+ * input.addEventListener('input', (e) => {
+ *   validator(item, e, input, help, emailValidator);
+ * });
+ *
+ * @example
+ * // Custom validator with multiple conditions
+ * const passwordValidator = (value) => {
+ *   return value.length >= 8 &&
+ *          /[A-Z]/.test(value) &&
+ *          /[0-9]/.test(value);
+ * };
+ * const field = renderField({
+ *   label: 'Password',
+ *   field: 'password',
+ *   type: 'password',
+ *   validator: passwordValidator,
+ *   error: 'Password must be 8+ chars with uppercase and number'
+ * });
+ */
+export declare function validator(item: any, e: any, input: HTMLElement, help: HTMLElement, fx?: (value: string) => boolean): void;

package/dist/components/generateRound.d.ts

@@ -0,0 +1,6 @@
+import { Composition, MatchUp } from '../types';
+export declare const generateRound: ({ composition, roundNumber, matchUps }: {
+    composition?: Composition;
+    roundNumber: number;
+    matchUps?: MatchUp[];
+}) => HTMLElement;

package/dist/components/inline-scoring/engineToMatchUp.d.ts

@@ -0,0 +1,6 @@
+import { MatchUp } from '../../types';
+/**
+ * Bridge: converts ScoringEngine state into a TODS-compatible MatchUp object
+ * suitable for renderMatchUp(). Injects live point display into the active set.
+ */
+export declare function engineToMatchUp(engine: any, baseMatchUp: MatchUp): MatchUp;

package/dist/components/inline-scoring/index.d.ts

@@ -0,0 +1,5 @@
+export { InlineScoringManager } from './inlineScoringManager';
+export { renderInlineMatchUp } from './renderInlineMatchUp';
+export { engineToMatchUp } from './engineToMatchUp';
+export { createInlineScoringFooter } from './inlineScoringFooter';
+export type { InlineScoringMode, InlineScoringConfig, InlineScoringCallbacks, InlineScoringEngineState } from './inlineScoringTypes';

package/dist/components/inline-scoring/inlineScoringFooter.d.ts

@@ -0,0 +1,18 @@
+import { InlineScoringManager } from './inlineScoringManager';
+import { MatchUp } from '../../types';
+interface FooterParams {
+    matchUpId: string;
+    manager: InlineScoringManager;
+    baseMatchUp: MatchUp;
+    onUpdate: (matchUp: MatchUp) => void;
+    showSituation?: boolean;
+}
+/**
+ * Creates an interactive footer bar for inline scoring:
+ * [Undo] [Redo] [Clear] [Submit]  |  situation flags
+ */
+export declare function createInlineScoringFooter(params: FooterParams): {
+    element: HTMLElement;
+    update: () => void;
+};
+export {};

package/dist/components/inline-scoring/inlineScoringManager.d.ts

@@ -0,0 +1,49 @@
+import { MatchUp } from '../../types';
+import { InlineScoringCallbacks, InlineScoringEngineState } from './inlineScoringTypes';
+/**
+ * Manages ScoringEngine instances for inline scoring in draw brackets.
+ * One engine per matchUpId; lazily created on first interaction.
+ */
+export declare class InlineScoringManager {
+    private engines;
+    readonly callbacks: InlineScoringCallbacks;
+    constructor(callbacks?: InlineScoringCallbacks);
+    /**
+     * Get or create a ScoringEngine for a matchUp.
+     * If the matchUp has existing score data, initializes the engine with it.
+     */
+    getOrCreate(matchUpId: string, matchUpFormat: string, existingMatchUp?: MatchUp): InlineScoringEngineState;
+    get(matchUpId: string): InlineScoringEngineState | undefined;
+    has(matchUpId: string): boolean;
+    /**
+     * Add a point for a side. Used in 'points' mode.
+     * @param winner - 0 for side 1, 1 for side 2
+     */
+    addPoint(matchUpId: string, winner: 0 | 1, baseMatchUp: MatchUp): MatchUp | undefined;
+    /**
+     * Add a game for a side. Used in 'games' mode.
+     * @param winner - 0 for side 1, 1 for side 2
+     */
+    addGame(matchUpId: string, winner: 0 | 1, baseMatchUp: MatchUp): MatchUp | undefined;
+    /**
+     * Add a set score. Used in 'entry' mode.
+     */
+    addSet(matchUpId: string, side1Score: number, side2Score: number, baseMatchUp: MatchUp): MatchUp | undefined;
+    undo(matchUpId: string, baseMatchUp: MatchUp): MatchUp | undefined;
+    redo(matchUpId: string, baseMatchUp: MatchUp): MatchUp | undefined;
+    reset(matchUpId: string, baseMatchUp: MatchUp): MatchUp | undefined;
+    /**
+     * Get the current engine-derived matchUp data.
+     */
+    getMatchUp(matchUpId: string, baseMatchUp: MatchUp): MatchUp;
+    /**
+     * Get situation flags (break point, set point, etc.) for display.
+     */
+    getSituation(matchUpId: string): Record<string, boolean> | undefined;
+    canUndo(matchUpId: string): boolean;
+    canRedo(matchUpId: string): boolean;
+    isComplete(matchUpId: string): boolean;
+    remove(matchUpId: string): void;
+    clear(): void;
+    private notifyAndReturn;
+}

package/dist/components/inline-scoring/inlineScoringTypes.d.ts

@@ -0,0 +1,40 @@
+import { MatchUp } from '../../types';
+export type InlineScoringMode = 'points' | 'games';
+export interface InlineScoringConfig {
+    mode: InlineScoringMode;
+    showFooter?: boolean;
+    showSituation?: boolean;
+    /** Runtime state for footer buttons — set by renderInlineMatchUp before calling renderMatchUp */
+    canUndo?: boolean;
+    canRedo?: boolean;
+    isComplete?: boolean;
+    situationText?: string;
+}
+export interface InlineScoringCallbacks {
+    onScoreChange?: (params: {
+        matchUpId: string;
+        matchUp: MatchUp;
+        engine: any;
+    }) => void;
+    onMatchComplete?: (params: {
+        matchUpId: string;
+        winningSide: number;
+        engine: any;
+    }) => void;
+    onEndMatch?: (params: {
+        matchUpId: string;
+        matchUpStatus: string;
+        sideNumber?: number;
+        engine: any;
+    }) => void;
+    onSubmit?: (params: {
+        matchUpId: string;
+        matchUp: MatchUp;
+        engine: any;
+    }) => void;
+}
+export interface InlineScoringEngineState {
+    engine: any;
+    matchUpFormat: string;
+    pointCount: number;
+}

package/dist/components/inline-scoring/renderInlineMatchUp.d.ts

@@ -0,0 +1,27 @@
+import { InlineScoringManager } from './inlineScoringManager';
+import { Composition, EventHandlers, MatchUp } from '../../types';
+interface RenderInlineMatchUpParams {
+    matchUp: MatchUp;
+    composition: Composition;
+    manager: InlineScoringManager;
+    matchUpFormat?: string;
+    eventHandlers?: EventHandlers;
+    isLucky?: boolean;
+    isAdHoc?: boolean;
+    className?: string;
+    moiety?: boolean;
+    initialRoundNumber?: number;
+    isFinalRound?: boolean;
+    searchActive?: boolean;
+    selectedMatchUpId?: string;
+}
+/**
+ * Renders a matchUp with inline scoring interactivity.
+ * Sets up event handlers and configuration state, then delegates to `renderMatchUp`.
+ * The footer buttons (Undo/Redo/Clear/Submit) are rendered by `renderMatchUp` itself,
+ * driven by the inlineScoring config state and eventHandlers passed down.
+ *
+ * Returns a container element that re-renders itself after each scoring action.
+ */
+export declare function renderInlineMatchUp(params: RenderInlineMatchUpParams): HTMLElement;
+export {};

package/dist/components/interactive-scoring/buildInteractiveScoringShell.d.ts

@@ -0,0 +1,28 @@
+import { InteractiveScoringShell, InteractiveScoringShellConfig } from './types';
+/**
+ * Build a mobile-first full-page interactive scoring shell around a
+ * `ScoringEngine` (wrapped by the existing `InlineScoringManager`).
+ *
+ * This is the courthive-public Phase 2 scoring UI: anonymous,
+ * local-only, mobile-first. It does NOT persist state itself —
+ * consumers subscribe to `stateChanged` events and handle
+ * persistence (IndexedDB in courthive-public's case).
+ *
+ * Phase 2 targets standard tennis matchUpFormats (`SET3-S:6/TB7`,
+ * `SET5-S:6/TB7`, etc.). INTENNSE bolt scoring, pickleball score
+ * caps, doubles lineup changes, and other format-specific behaviors
+ * are deferred to Phase 2.5+.
+ *
+ * The DOM structure:
+ * ```
+ * .chc-interactive-scoring-shell
+ *   .chc-iss-header          (side names + format indicator)
+ *   .chc-iss-score-display   (current set scores + game score)
+ *   .chc-iss-point-buttons   (big Side 1 / Side 2 point-won buttons)
+ *   .chc-iss-control-bar     (undo, reset, complete indicator)
+ * ```
+ *
+ * All styling lives in `interactive-scoring.css` using the shared
+ * `--sp-*` / `--chc-*` theme variables.
+ */
+export declare function buildInteractiveScoringShell(config: InteractiveScoringShellConfig): InteractiveScoringShell;

package/dist/components/interactive-scoring/index.d.ts

@@ -0,0 +1,2 @@
+export { buildInteractiveScoringShell } from './buildInteractiveScoringShell';
+export type { InteractiveScoringShell, InteractiveScoringShellConfig, StateChangedDetail, } from './types';

package/dist/components/interactive-scoring/types.d.ts

@@ -0,0 +1,60 @@
+import { MatchUp } from '../../types';
+/**
+ * Configuration for `buildInteractiveScoringShell`.
+ *
+ * The shell is a mobile-first, full-page interactive scoring UI that
+ * wraps a `ScoringEngine` (via the existing `InlineScoringManager`)
+ * and presents two large point-entry buttons, a current score
+ * display, and a control bar with undo/reset.
+ *
+ * The shell is stateful but emits a `stateChanged` CustomEvent on
+ * every point so consumers (courthive-public for Phase 2) can
+ * persist the current MatchUp to IndexedDB or any other store.
+ *
+ * Phase 2 targets standard tennis matchUpFormats. INTENNSE, pickleball,
+ * and other formats are deferred to Phase 2.5+.
+ */
+export interface InteractiveScoringShellConfig {
+    /** Unique matchUp id — used as the engine key and the persistence key. */
+    matchUpId: string;
+    /** matchUpFormat code, e.g. `'SET3-S:6/TB7'`. */
+    matchUpFormat: string;
+    /** Tournament id, for context display only (never sent anywhere). */
+    tournamentId: string;
+    /** Display name for side 1 (singles player or doubles pair). */
+    side1Name: string;
+    /** Display name for side 2. */
+    side2Name: string;
+    /**
+     * Optional initial MatchUp to resume from — typically loaded from
+     * IndexedDB. If omitted, the shell starts at 0-0.
+     */
+    initialMatchUp?: MatchUp;
+}
+/**
+ * Detail payload for the `stateChanged` CustomEvent.
+ */
+export interface StateChangedDetail {
+    matchUpId: string;
+    matchUp: MatchUp;
+    isComplete: boolean;
+    winningSide?: number;
+}
+/**
+ * Handle returned by `buildInteractiveScoringShell`. Consumers mount
+ * `element` into the DOM, subscribe to state changes via
+ * `addEventListener`, and call `destroy()` on unmount.
+ */
+export interface InteractiveScoringShell {
+    /** The root DOM element for the scoring UI. Mount this into the page. */
+    element: HTMLElement;
+    /** Get the current MatchUp snapshot (for persistence). */
+    getState(): MatchUp;
+    /** Reset the scoring engine to 0-0. */
+    reset(): void;
+    /** Remove all listeners and release engine resources. */
+    destroy(): void;
+    /** Subscribe to state change events. */
+    addEventListener(type: 'stateChanged', listener: (event: CustomEvent<StateChangedDetail>) => void): void;
+    removeEventListener(type: 'stateChanged', listener: (event: CustomEvent<StateChangedDetail>) => void): void;
+}

package/dist/components/matchUpFormat/matchUpFormat.d.ts

@@ -0,0 +1,81 @@
+interface MatchUpFormatConfig {
+    labels?: {
+        title?: string;
+        setFormatLabel?: string;
+        finalSetLabel?: string;
+        tiebreakLabel?: string;
+        finalSetToggleLabel?: string;
+        standardFormatsLabel?: string;
+        cancel?: string;
+        select?: string;
+        custom?: string;
+        aggregate?: string;
+        game?: string;
+        gameType?: string;
+        deuceRule?: string;
+        none?: string;
+        traditional?: string;
+        consecutive2?: string;
+        consecutive3?: string;
+        consecutive4?: string;
+        goldenPoint?: string;
+        starPoint?: string;
+        games?: string;
+        points?: string;
+        descriptors?: {
+            bestOf?: string;
+            exactly?: string;
+        };
+        what?: {
+            sets?: string;
+            tiebreaks?: string;
+            timedSets?: string;
+        };
+        advantage?: {
+            ad?: string;
+            noAd?: string;
+        };
+    };
+    options?: {
+        bestOf?: number[];
+        exactly?: number[];
+        setTo?: number[];
+        tiebreakTo?: number[];
+        tiebreakToExactly?: number[];
+        tiebreakAt?: number[];
+        minutes?: number[];
+        winBy?: number[];
+        matchRoots?: string[];
+        gameFormats?: string[];
+        modifiers?: string[];
+    };
+    preDefinedFormats?: Array<{
+        code: string;
+        text: string;
+    }>;
+}
+export declare function getMatchUpFormatModal({ existingMatchUpFormat, callback, config, modalConfig }?: {
+    existingMatchUpFormat?: string;
+    callback?: (format: string) => void;
+    config?: MatchUpFormatConfig;
+    modalConfig?: any;
+}): {
+    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;
+};
+export {};

package/dist/components/matchUpFormat/matchUpFormatLogic.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Pure logic for match format configuration
+ * Extracted from matchUpFormat.ts for testability
+ */
+export declare const TIMED_SETS = "Timed set";
+export declare const TIEBREAKS = "Tiebreak";
+export declare const NOAD = "No-Ad";
+export declare const SETS = "Set";
+export declare const AD = "Ad";
+export declare const MATCH_ROOTS: readonly ["SET", "HAL", "QTR", "PER", "INN", "RND", "FRM", "MAP"];
+export declare const MATCH_ROOT_LABELS: Record<string, string>;
+/**
+ * Returns valid bestOf options for a given match root.
+ * SET root: [1,3,5] (standard tennis)
+ * Other roots: [1..12] (wide range for cross-sport)
+ */
+export declare function getBestOfOptionsForRoot(matchRoot?: string): number[];
+export interface SetFormatConfig {
+    descriptor: string;
+    bestOf?: number;
+    exactly?: number;
+    advantage: string;
+    what: string;
+    setTo: number;
+    tiebreakAt: number;
+    tiebreakTo: number;
+    winBy: number;
+    minutes: number;
+    based?: string;
+    modifier?: string;
+}
+export interface FormatConfig {
+    matchRoot?: string;
+    aggregate?: boolean;
+    gameFormat?: {
+        type: 'CONSECUTIVE';
+        count: number;
+        deuceAfter?: number;
+    } | {
+        type: 'TRADITIONAL';
+        deuceAfter?: number;
+    };
+    setFormat: SetFormatConfig;
+    finalSetFormat: SetFormatConfig;
+}
+export interface ParsedMatchUpFormat {
+    matchRoot?: string;
+    aggregate?: boolean;
+    gameFormat?: {
+        type: 'CONSECUTIVE';
+        count: number;
+        deuceAfter?: number;
+    } | {
+        type: 'TRADITIONAL';
+        deuceAfter?: number;
+    };
+    bestOf?: number;
+    exactly?: number;
+    setFormat: any;
+    finalSetFormat?: any;
+}
+/**
+ * Create default set format configuration
+ */
+export declare function createDefaultSetFormat(isFinalSet?: boolean): SetFormatConfig;
+/**
+ * Create default format configuration
+ */
+export declare function createDefaultFormat(): FormatConfig;
+/**
+ * Check if a set format is tiebreak-only (e.g., F:TB10)
+ */
+export declare function isTiebreakOnlySet(setFormat: any): boolean;
+/**
+ * Generate a setFormat object from FormatConfig
+ * Pure function - no DOM dependencies
+ */
+export declare function buildSetFormat(config: SetFormatConfig, hasTiebreak: boolean): any;
+/**
+ * Build parsed matchUp format from current configuration
+ * Pure function - no DOM dependencies
+ */
+export declare function buildParsedFormat(config: FormatConfig, hasSetTiebreak: boolean, hasFinalSet: boolean, hasFinalSetTiebreak: boolean): ParsedMatchUpFormat;
+/**
+ * Determine which components should be visible based on the current 'what' value
+ */
+export declare function getComponentVisibility(what: string): {
+    setTo: boolean;
+    tiebreakAt: boolean;
+    tiebreakTo: boolean;
+    winBy: boolean;
+    advantage: boolean;
+    minutes: boolean;
+};
+/**
+ * Calculate valid tiebreakAt options based on setTo value
+ */
+export declare function getTiebreakAtOptions(setTo: number): number[];
+/**
+ * Auto-adjust tiebreakAt when setTo changes
+ * Returns the new tiebreakAt value that should be used
+ */
+export declare function autoAdjustTiebreakAt(newSetTo: number, currentTiebreakAt: number): number;
+/**
+ * Validate that a tiebreakAt value is valid for the given setTo
+ */
+export declare function isValidTiebreakAt(setTo: number, tiebreakAt: number): boolean;
+/**
+ * Check if final set option should be shown
+ */
+export declare function shouldShowFinalSetOption(bestOf: number): boolean;
+export declare function initializeFormatFromString(matchUpFormat: string, parseFunction: (format: string) => any): FormatConfig;

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

@@ -0,0 +1,30 @@
+import { ModalButton, ModalConfig, ModalParams } from '../../types';
+type ModalContent = string | HTMLElement | ((container: HTMLElement) => any);
+export declare function isFunction(fx: any): fx is (...args: any[]) => any;
+export declare function isString(item: any): item is string;
+export declare function isArray(item: any): item is any[];
+export declare function isObject(item: any): item is object;
+export declare function removeAllChildNodes(parent: HTMLElement | null): void;
+export declare const cModal: {
+    close: (conditional?: boolean) => void;
+    open: ({ title, content, buttons, footer, config, onClose }?: ModalParams) => {
+        setContent: ({ content: newContent, config }: {
+            content?: ModalContent;
+            config?: ModalConfig;
+        }) => void;
+        setButtons: ({ buttons, config }: {
+            buttons: ModalButton[];
+            config?: ModalConfig;
+        }) => void;
+        update: ({ content: newContent, buttons, title, config: newConfig, onClose }: {
+            content?: ModalContent;
+            buttons?: ModalButton[];
+            title?: string;
+            config?: ModalConfig;
+            onClose?: (params: {
+                content?: any;
+            }) => void;
+        }) => void;
+    };
+};
+export {};

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

@@ -0,0 +1,8 @@
+export declare const backdropStyle: () => string;
+export declare const modalStyle: () => string;
+export declare const bodyFreeze: () => string;
+export declare const modalContainerStyle: () => string;
+export declare const modalDialogStyle: () => string;
+export declare const modalHeaderStyle: () => string;
+export declare const modalTitleStyle: () => string;
+export declare const modalFooterStyle: () => string;