@e-llm-studio/requirement-ai 0.0.259 → 0.0.262

package/dist/types/src/features/CognitiveCompare/Guidelines/constants/guidelines.mockData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"guidelines.mockData.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/CognitiveCompare/Guidelines/constants/guidelines.mockData.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+jD7B,CAAA;AAGD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4/B1B,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6S1B,CAAA"}

package/dist/types/src/features/CognitiveCompare/Guidelines/utils/helper.d.ts

@@ -1,11 +0,0 @@
-export declare const mergeRulebookCitationsIntoMatchingLinks: (rawContent: string) => string;
-export declare const processGuidelinesMarkdown: ({ guidelinesData, targetHighlights, labelColor, }: {
-    guidelinesData: any;
-    targetHighlights?: string[] | undefined;
-    labelColor?: string | undefined;
-}) => string;
-export declare const getCitationNumberFromHref: (url: string) => {
-    citationNumber: string | null;
-    phraseToHighlight: string | null;
-};
-//# sourceMappingURL=helper.d.ts.map

package/dist/types/src/features/CognitiveCompare/Guidelines/utils/helper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/CognitiveCompare/Guidelines/utils/helper.ts"],"names":[],"mappings":"AA6IA,eAAO,MAAM,uCAAuC,eAAgB,MAAM,WAmGzE,CAAC;AAEF,eAAO,MAAM,yBAAyB;oBAKpB,GAAG;;;YAkDpB,CAAC;AAGF,eAAO,MAAM,yBAAyB,QAAS,MAAM,KAAG;IAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;CAiBxH,CAAC"}

package/dist/types/src/features/CognitiveCompare/Guidelines/utils/processGuidelinesMarkdown.d.ts

@@ -1,6 +0,0 @@
-export declare const processGuidelinesMarkdown: ({ guidelinesData, targetHighlights, labelColor, }: {
-    guidelinesData: any;
-    targetHighlights?: string[] | undefined;
-    labelColor?: string | undefined;
-}) => string;
-//# sourceMappingURL=processGuidelinesMarkdown.d.ts.map

package/dist/types/src/features/CognitiveCompare/Guidelines/utils/processGuidelinesMarkdown.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"processGuidelinesMarkdown.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/CognitiveCompare/Guidelines/utils/processGuidelinesMarkdown.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB;oBAKpB,GAAG;;;YA4CpB,CAAC"}

package/dist/types/src/features/CognitiveCompare/LoaderComponent.d.ts

@@ -1,3 +0,0 @@
-declare const BouncingDotsLoader: () => import("react/jsx-runtime").JSX.Element;
-export default BouncingDotsLoader;
-//# sourceMappingURL=LoaderComponent.d.ts.map

package/dist/types/src/features/CognitiveCompare/LoaderComponent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LoaderComponent.d.ts","sourceRoot":"","sources":["../../../../../src/features/CognitiveCompare/LoaderComponent.tsx"],"names":[],"mappings":"AAGA,QAAA,MAAM,kBAAkB,+CA8DvB,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/types/src/features/CognitiveCompare/MoreFunctionsPopup.d.ts

@@ -1,19 +0,0 @@
-import React from "react";
-type MoreFunctionsPopupProps = {
-    open: boolean;
-    anchorEl: HTMLElement | null;
-    sectionTitle: string;
-    referenceSectionTitle: string;
-    onClose: () => void;
-    onOpenCognitiveCompare: () => void;
-    onOpenSideBySide: () => void;
-    onConnect: () => void;
-    isConnected?: boolean;
-    isOrphan: boolean;
-    maintainRelativeOrder?: boolean;
-    isGuidelineMode?: boolean;
-    hasGuidelineMatches?: boolean;
-};
-declare const MoreFunctionsPopup: React.FC<MoreFunctionsPopupProps>;
-export default MoreFunctionsPopup;
-//# sourceMappingURL=MoreFunctionsPopup.d.ts.map

package/dist/types/src/features/CognitiveCompare/MoreFunctionsPopup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MoreFunctionsPopup.d.ts","sourceRoot":"","sources":["../../../../../src/features/CognitiveCompare/MoreFunctionsPopup.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,KAAK,uBAAuB,GAAG;IAC3B,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,sBAAsB,EAAE,MAAM,IAAI,CAAC;IACnC,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,EAAE,OAAO,CAAC;IAClB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAqCF,QAAA,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,CAAC,uBAAuB,CAsMzD,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/types/src/features/CognitiveCompare/OverlayComponent.d.ts

@@ -1,5 +0,0 @@
-declare const OverlayLoader: ({ sections }: {
-    sections?: number | undefined;
-}) => import("react/jsx-runtime").JSX.Element;
-export default OverlayLoader;
-//# sourceMappingURL=OverlayComponent.d.ts.map

package/dist/types/src/features/CognitiveCompare/OverlayComponent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OverlayComponent.d.ts","sourceRoot":"","sources":["../../../../../src/features/CognitiveCompare/OverlayComponent.tsx"],"names":[],"mappings":"AAEA,QAAA,MAAM,aAAa;;6CAwFlB,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/types/src/features/CognitiveCompare/ResizableSplitPane.d.ts

@@ -1,9 +0,0 @@
-import React, { ReactNode } from "react";
-interface ResizableSplitPaneProps {
-    leftComponent?: ReactNode;
-    rightComponent?: ReactNode;
-    isFullscreen?: boolean;
-}
-declare const ResizableSplitPane: React.FC<ResizableSplitPaneProps>;
-export default ResizableSplitPane;
-//# sourceMappingURL=ResizableSplitPane.d.ts.map

package/dist/types/src/features/CognitiveCompare/ResizableSplitPane.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ResizableSplitPane.d.ts","sourceRoot":"","sources":["../../../../../src/features/CognitiveCompare/ResizableSplitPane.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EACZ,SAAS,EAIV,MAAM,OAAO,CAAC;AAEf,UAAU,uBAAuB;IAC/B,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B,cAAc,CAAC,EAAE,SAAS,CAAC;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,QAAA,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,CAAC,uBAAuB,CAiIzD,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/types/src/features/CognitiveCompare/components/CognitiveSummaryPopup.d.ts

@@ -1,3 +0,0 @@
-import { CognitiveSummaryPopupProps } from "../CognitiveCompareTypes";
-export default function CognitiveSummaryPopup({ open, anchorEl, containerEl, clipTopEl, scrollContainerEl, onClose, summary, markdownStyles, isLoading, displayImpact, isScrollLocked, }: CognitiveSummaryPopupProps): import("react/jsx-runtime").JSX.Element | null;
-//# sourceMappingURL=CognitiveSummaryPopup.d.ts.map

package/dist/types/src/features/CognitiveCompare/components/CognitiveSummaryPopup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CognitiveSummaryPopup.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/components/CognitiveSummaryPopup.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AAoBtE,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAAC,EAC5C,IAAI,EACJ,QAAQ,EACR,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,OAAO,EACP,OAAO,EACP,cAAc,EACd,SAAS,EACT,aAAa,EACb,cAAc,GACf,EAAE,0BAA0B,kDAka5B"}

package/dist/types/src/features/CognitiveCompare/components/CompareHeader.d.ts

@@ -1,12 +0,0 @@
-import { IDisplayConfig } from "../CognitiveCompareTypes";
-type CompareHeaderProps = {
-    componentHeaderText: string;
-    displayConfig: IDisplayConfig;
-    maintainRelativeOrder: boolean | undefined;
-    onToggleView: (isDefaultView: boolean) => void;
-    onCollapseAll: () => void;
-    showCollapseAll: boolean;
-};
-declare const CompareHeader: ({ componentHeaderText, displayConfig, maintainRelativeOrder, onToggleView, onCollapseAll, showCollapseAll, }: CompareHeaderProps) => import("react/jsx-runtime").JSX.Element | null;
-export default CompareHeader;
-//# sourceMappingURL=CompareHeader.d.ts.map

package/dist/types/src/features/CognitiveCompare/components/CompareHeader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CompareHeader.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/components/CompareHeader.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D,KAAK,kBAAkB,GAAG;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,cAAc,CAAC;IAC9B,qBAAqB,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3C,YAAY,EAAE,CAAC,aAAa,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/C,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,QAAA,MAAM,aAAa,iHAOhB,kBAAkB,mDA6IpB,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/types/src/features/CognitiveCompare/components/LHSSectionRow.d.ts

@@ -1,9 +0,0 @@
-import React from "react";
-import { SectionBlock } from "../CognitiveCompareTypes";
-type LHSSectionRowProps = {
-    section: SectionBlock;
-    idx: number;
-};
-declare const LHSSectionRow: React.MemoExoticComponent<({ section, idx, }: LHSSectionRowProps) => import("react/jsx-runtime").JSX.Element | null>;
-export default LHSSectionRow;
-//# sourceMappingURL=LHSSectionRow.d.ts.map

package/dist/types/src/features/CognitiveCompare/components/LHSSectionRow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LHSSectionRow.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/components/LHSSectionRow.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAQ1B,OAAO,EAAE,YAAY,EAAgB,MAAM,0BAA0B,CAAC;AAQtE,KAAK,kBAAkB,GAAG;IACxB,OAAO,EAAE,YAAY,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,QAAA,MAAM,aAAa,gDAId,kBAAkB,oDAuMtB,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/types/src/features/CognitiveCompare/components/RHSSectionRow.d.ts

@@ -1,9 +0,0 @@
-import React from "react";
-import { SectionBlock } from "../CognitiveCompareTypes";
-type RHSSectionRowProps = {
-    section: SectionBlock;
-    idx: number;
-};
-declare const RHSSectionRow: React.MemoExoticComponent<({ section, idx, }: RHSSectionRowProps) => import("react/jsx-runtime").JSX.Element>;
-export default RHSSectionRow;
-//# sourceMappingURL=RHSSectionRow.d.ts.map

package/dist/types/src/features/CognitiveCompare/components/RHSSectionRow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RHSSectionRow.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/components/RHSSectionRow.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAY1B,OAAO,EAAE,YAAY,EAAgB,MAAM,0BAA0B,CAAC;AAQtE,KAAK,kBAAkB,GAAG;IACxB,OAAO,EAAE,YAAY,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,QAAA,MAAM,aAAa,gDAId,kBAAkB,6CA+UtB,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/types/src/features/CognitiveCompare/components/ScrollLockToggle.d.ts

@@ -1,11 +0,0 @@
-import React from "react";
-type ScrollLockToggleProps = {
-    locked: boolean;
-    onToggle: (e: React.MouseEvent) => void;
-    color?: string;
-    borderColor?: string;
-    size?: number;
-};
-declare const ScrollLockToggle: ({ locked, onToggle, color, borderColor, size, }: ScrollLockToggleProps) => import("react/jsx-runtime").JSX.Element;
-export default ScrollLockToggle;
-//# sourceMappingURL=ScrollLockToggle.d.ts.map

package/dist/types/src/features/CognitiveCompare/components/ScrollLockToggle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ScrollLockToggle.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/components/ScrollLockToggle.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,KAAK,qBAAqB,GAAG;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAOF,QAAA,MAAM,gBAAgB,oDAMnB,qBAAqB,4CAkCvB,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/types/src/features/CognitiveCompare/components/SectionAccordion.d.ts

@@ -1,17 +0,0 @@
-import React from "react";
-import { SectionBlock } from "../CognitiveCompareTypes";
-import { DeviationNavigationEntry } from "../hooks/useDeviationNavigation";
-type SectionAccordionProps = {
-    section: SectionBlock;
-    idx: number;
-    columnKey: "left" | "right";
-    colRef: React.RefObject<HTMLDivElement>;
-    mb?: number;
-    parentNodeId?: string;
-    isExpanded: boolean;
-    onToggle: () => void;
-    navigation: DeviationNavigationEntry | null;
-};
-declare const SectionAccordion: ({ section, idx, columnKey, colRef, mb, isExpanded, onToggle, navigation, parentNodeId, }: SectionAccordionProps) => import("react/jsx-runtime").JSX.Element;
-export default SectionAccordion;
-//# sourceMappingURL=SectionAccordion.d.ts.map

package/dist/types/src/features/CognitiveCompare/components/SectionAccordion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SectionAccordion.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/components/SectionAccordion.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4B,MAAM,OAAO,CAAC;AA2BjD,OAAO,EAAsB,YAAY,EAAgB,MAAM,0BAA0B,CAAC;AAC1F,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAyF3E,KAAK,qBAAqB,GAAG;IAC3B,OAAO,EAAE,YAAY,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5B,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,UAAU,EAAE,wBAAwB,GAAG,IAAI,CAAC;CAC7C,CAAC;AAEF,QAAA,MAAM,gBAAgB,6FAUnB,qBAAqB,4CAw4BvB,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/types/src/features/CognitiveCompare/components/SubSectionAccordion.d.ts

@@ -1,14 +0,0 @@
-import React from "react";
-import { SectionBlock } from "../CognitiveCompareTypes";
-interface SubSectionAccordionProps {
-    section: SectionBlock;
-    keyPath: string;
-    depth?: number;
-    columnKey?: "left" | "right";
-    parentNodeId?: string;
-    sectionOffset?: number;
-    rhsOrphanVisualIndexes?: ReadonlyMap<string, number>;
-}
-declare const SubSectionAccordion: React.FC<SubSectionAccordionProps>;
-export default SubSectionAccordion;
-//# sourceMappingURL=SubSectionAccordion.d.ts.map

package/dist/types/src/features/CognitiveCompare/components/SubSectionAccordion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SubSectionAccordion.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/components/SubSectionAccordion.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqC,MAAM,OAAO,CAAC;AA4B1D,OAAO,EAAsB,YAAY,EAAgB,MAAM,0BAA0B,CAAC;AAE1F,UAAU,wBAAwB;IAChC,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtD;AAED,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CA+mB1D,CAAC;AAEH,eAAe,mBAAmB,CAAC"}

package/dist/types/src/features/CognitiveCompare/components/SvgConnectors.d.ts

@@ -1,37 +0,0 @@
-/// <reference types="react" />
-import { SectionBlock, SectionPopupState, StyleVariant } from "../CognitiveCompareTypes";
-type SvgConnectorsProps = {
-    svgContainerRef: React.MutableRefObject<SVGSVGElement | null>;
-    svgDimensions: {
-        width: number;
-        height: number;
-    };
-    isResizing: boolean;
-    overallConnector: {
-        x1: number;
-        x2: number;
-        y: number;
-    } | null;
-    rootDeviationStyle: {
-        badgeBorder: string;
-    };
-    lines: Record<string, any>[];
-    isSideBySide: boolean;
-    activeSideBySideSection: number | string | null;
-    isArrowVisible: boolean;
-    maintainRelativeOrder: boolean | undefined;
-    proposedSections: SectionBlock[];
-    existingSections: SectionBlock[];
-    cognitivePopup: SectionPopupState;
-    activeBadgeId: string | null;
-    closeCognitivePopup: () => void;
-    setActiveBadgeId: React.Dispatch<React.SetStateAction<string | null>>;
-    openCognitivePopupFromState: (nextPopup: SectionPopupState) => void;
-    buildSectionPopupState: (anchorEl: HTMLElement | null, baseSec: SectionBlock | null, refSec: SectionBlock | null, sectionIdx: number | string, isOrphan?: boolean, style?: StyleVariant | null, rootNode?: boolean) => SectionPopupState;
-    connectedLines: Record<string, any>[];
-    pathRefs: React.MutableRefObject<Record<string, SVGPathElement | null>>;
-    isGuidelineMode?: boolean;
-};
-export default function SvgConnectors({ svgContainerRef, svgDimensions, isResizing, overallConnector, rootDeviationStyle, lines, isSideBySide, activeSideBySideSection, isArrowVisible, maintainRelativeOrder, proposedSections, existingSections, cognitivePopup, activeBadgeId, closeCognitivePopup, setActiveBadgeId, openCognitivePopupFromState, buildSectionPopupState, connectedLines, pathRefs, isGuidelineMode, }: SvgConnectorsProps): import("react/jsx-runtime").JSX.Element;
-export {};
-//# sourceMappingURL=SvgConnectors.d.ts.map

package/dist/types/src/features/CognitiveCompare/components/SvgConnectors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SvgConnectors.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/components/SvgConnectors.tsx"],"names":[],"mappings":";AAOA,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAiBlC,KAAK,kBAAkB,GAAG;IACxB,eAAe,EAAE,KAAK,CAAC,gBAAgB,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;IAC9D,aAAa,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACjD,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC/D,kBAAkB,EAAE;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;IAC7B,YAAY,EAAE,OAAO,CAAC;IACtB,uBAAuB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAChD,cAAc,EAAE,OAAO,CAAC;IACxB,qBAAqB,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3C,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,cAAc,EAAE,iBAAiB,CAAC;IAClC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,mBAAmB,EAAE,MAAM,IAAI,CAAC;IAChC,gBAAgB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IACtE,2BAA2B,EAAE,CAAC,SAAS,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACpE,sBAAsB,EAAE,CACtB,QAAQ,EAAE,WAAW,GAAG,IAAI,EAC5B,OAAO,EAAE,YAAY,GAAG,IAAI,EAC5B,MAAM,EAAE,YAAY,GAAG,IAAI,EAC3B,UAAU,EAAE,MAAM,GAAG,MAAM,EAC3B,QAAQ,CAAC,EAAE,OAAO,EAClB,KAAK,CAAC,EAAE,YAAY,GAAG,IAAI,EAC3B,QAAQ,CAAC,EAAE,OAAO,KACf,iBAAiB,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;IACtC,QAAQ,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC,CAAC,CAAC;IACxE,eAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,EACpC,eAAe,EACf,aAAa,EACb,UAAU,EACV,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,EACL,YAAY,EACZ,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAChB,2BAA2B,EAC3B,sBAAsB,EACtB,cAAc,EACd,QAAQ,EACR,eAAe,GAChB,EAAE,kBAAkB,2CA8NpB"}

package/dist/types/src/features/CognitiveCompare/components/ThreeDotsLoader.d.ts

@@ -1,8 +0,0 @@
-interface ThreeDotsLoaderProps {
-    size?: number;
-    color?: string;
-    gap?: number;
-}
-declare const ThreeDotsLoader: ({ size, color, gap, }: ThreeDotsLoaderProps) => import("react/jsx-runtime").JSX.Element;
-export default ThreeDotsLoader;
-//# sourceMappingURL=ThreeDotsLoader.d.ts.map

package/dist/types/src/features/CognitiveCompare/components/ThreeDotsLoader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ThreeDotsLoader.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/components/ThreeDotsLoader.tsx"],"names":[],"mappings":"AAEA,UAAU,oBAAoB;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,QAAA,MAAM,eAAe,0BAIlB,oBAAoB,4CA4BtB,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/dist/types/src/features/CognitiveCompare/components/connectedLines.d.ts

@@ -1,9 +0,0 @@
-import React from "react";
-declare const ConnectedLinesComp: ({ connectedLines, pathRefs, maintainRelativeOrder, }: {
-    connectedLines: Record<string, any>[];
-    pathRefs: React.MutableRefObject<Record<string, any>>;
-    maintainRelativeOrder?: boolean | undefined;
-    isGuidelineMode?: boolean | undefined;
-}) => import("react/jsx-runtime").JSX.Element;
-export default ConnectedLinesComp;
-//# sourceMappingURL=connectedLines.d.ts.map

package/dist/types/src/features/CognitiveCompare/components/connectedLines.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connectedLines.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/components/connectedLines.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,QAAA,MAAM,kBAAkB;oBAKN,OAAO,MAAM,EAAE,GAAG,CAAC,EAAE;cAC3B,MAAM,gBAAgB,CAAC,OAAO,MAAM,EAAE,GAAG,CAAC,CAAC;;;6CA6OtD,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/types/src/features/CognitiveCompare/hooks/memoizedMarkdown.d.ts

@@ -1,13 +0,0 @@
-import React from "react";
-export declare const MemoizedMarkdown: React.MemoExoticComponent<({ content, overlayContent, sxStyles, deviationBadges, highlights, maintainRelativeOrder, highlightBg, suppressHighlightBg, collisionKey }: {
-    content: string;
-    overlayContent?: string | undefined;
-    sxStyles: any;
-    deviationBadges?: any[] | undefined;
-    highlights?: string[] | undefined;
-    maintainRelativeOrder?: boolean | undefined;
-    highlightBg: string;
-    suppressHighlightBg?: boolean | undefined;
-    collisionKey?: string | number | undefined;
-}) => import("react/jsx-runtime").JSX.Element>;
-//# sourceMappingURL=memoizedMarkdown.d.ts.map

package/dist/types/src/features/CognitiveCompare/hooks/memoizedMarkdown.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoizedMarkdown.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/hooks/memoizedMarkdown.tsx"],"names":[],"mappings":"AACA,OAAO,KAAoE,MAAM,OAAO,CAAC;AAmBzF,eAAO,MAAM,gBAAgB;aAWlB,MAAM;;cAEL,GAAG;;;;iBAIA,MAAM;;;8CAmqBpB,CAAC"}

package/dist/types/src/features/CognitiveCompare/hooks/useAccordionState.d.ts

@@ -1,32 +0,0 @@
-import React from "react";
-import { SectionBlock } from "../CognitiveCompareTypes";
-type AccordionStateParams = {
-    maintainRelativeOrder: boolean;
-    proposedSections: SectionBlock[];
-    existingSections: SectionBlock[];
-    activeSideBySideSection: number | string | null;
-    connectedSections: Set<number | string>;
-    resetSideBySide: () => void;
-    setConnectedSections: React.Dispatch<React.SetStateAction<Set<number | string>>>;
-    setConnectedLines: React.Dispatch<React.SetStateAction<Record<string, any>[]>>;
-    cachedConnectedPositions: React.MutableRefObject<any[]>;
-    svgContainerRef: React.MutableRefObject<SVGSVGElement | null>;
-    isAnimatingRef: React.MutableRefObject<boolean>;
-    animationTimerRef: React.MutableRefObject<ReturnType<typeof setTimeout> | null>;
-    calculateLinesRef: React.MutableRefObject<() => void>;
-    sectionLeftRefs: React.MutableRefObject<Record<string | number, React.RefObject<HTMLDivElement>>>;
-    sectionRightRefs: React.MutableRefObject<Record<string | number, React.RefObject<HTMLDivElement>>>;
-    subSectionLeftRefs: React.MutableRefObject<Record<string, React.RefObject<HTMLDivElement>>>;
-    subSectionRightRefs: React.MutableRefObject<Record<string, React.RefObject<HTMLDivElement>>>;
-};
-export declare const useAccordionState: ({ maintainRelativeOrder, proposedSections, existingSections, activeSideBySideSection, connectedSections, resetSideBySide, setConnectedSections, setConnectedLines, cachedConnectedPositions, svgContainerRef, isAnimatingRef, animationTimerRef, calculateLinesRef, sectionLeftRefs, sectionRightRefs, subSectionLeftRefs, subSectionRightRefs, }: AccordionStateParams) => {
-    expandedSections: Record<string, boolean>;
-    setExpandedSections: React.Dispatch<React.SetStateAction<Record<string, boolean>>>;
-    expandedSubSections: Record<string, boolean>;
-    setExpandedSubSections: React.Dispatch<React.SetStateAction<Record<string, boolean>>>;
-    handleSubSectionToggle: (keyPath: string) => void;
-    toggleSection: (idx: number, columnKey: "left" | "right") => void;
-    forceExpandCrossWiredSections: (actionId: string | number | null) => void;
-};
-export {};
-//# sourceMappingURL=useAccordionState.d.ts.map

package/dist/types/src/features/CognitiveCompare/hooks/useAccordionState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAccordionState.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/hooks/useAccordionState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAgC,MAAM,OAAO,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAGxD,KAAK,oBAAoB,GAAG;IAC1B,qBAAqB,EAAE,OAAO,CAAC;IAC/B,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,uBAAuB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAChD,iBAAiB,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IACxC,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,oBAAoB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACjF,iBAAiB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/E,wBAAwB,EAAE,KAAK,CAAC,gBAAgB,CAAC,GAAG,EAAE,CAAC,CAAC;IACxD,eAAe,EAAE,KAAK,CAAC,gBAAgB,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;IAC9D,cAAc,EAAE,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAChD,iBAAiB,EAAE,KAAK,CAAC,gBAAgB,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAC,CAAC;IAChF,iBAAiB,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,IAAI,CAAC,CAAC;IACtD,eAAe,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAClG,gBAAgB,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IACnG,kBAAkB,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAC5F,mBAAmB,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CAC9F,CAAC;AAEF,eAAO,MAAM,iBAAiB,sVAkB3B,oBAAoB;;;;;sCA4EoB,MAAM;yBAUnB,MAAM,aAAa,MAAM,GAAG,OAAO;8CArDF,MAAM,GAAG,MAAM,GAAG,IAAI;CAuJpF,CAAC"}

package/dist/types/src/features/CognitiveCompare/hooks/useCompareData.d.ts

@@ -1,20 +0,0 @@
-import { ComparisonRow, SectionBlock, ProposedRuleData, RuleData, ComparisonConfig } from "../CognitiveCompareTypes";
-export declare const useCognitiveTreeData: (treeData: Record<string, any> | undefined, maintainRelativeOrder: boolean, deviationData: Record<string, any> | null, resolvedComparisonConfig: ComparisonConfig, enableDeviationSchemaBackwardCompatibility?: boolean, guidelinesData?: Record<string, any> | null) => {
-    isGuidelineMode: boolean;
-    activeProposed: ProposedRuleData;
-    activeVariants: never[] | RuleData[];
-    comparisonRows: ComparisonRow[];
-    existingRule: RuleData;
-    proposedSections: SectionBlock[];
-    existingSections: SectionBlock[];
-    visibleFields: import("../CognitiveCompareTypes").FieldConfigItem[];
-    parentDeviationRecord: Record<string, SectionBlock[]>;
-    deviationNumberRegistry: {
-        [k: string]: number;
-    };
-    deviationParentRegistry: {
-        [k: string]: number;
-    };
-    parseError: string | null;
-};
-//# sourceMappingURL=useCompareData.d.ts.map

package/dist/types/src/features/CognitiveCompare/hooks/useCompareData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useCompareData.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/hooks/useCompareData.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,gBAAgB,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAKrH,eAAO,MAAM,oBAAoB,aACrB,OAAO,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,yBAClB,OAAO,iBACf,OAAO,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,4BACf,gBAAgB,+CACE,OAAO,mBAClC,OAAO,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;;;;;;;;;;;;;;;;;CAwtB5C,CAAC"}

package/dist/types/src/features/CognitiveCompare/hooks/useCompareLayout.d.ts

@@ -1,25 +0,0 @@
-/// <reference types="react" />
-export declare const useCompareLayout: (initialMaintainOrder: boolean, scrollContainerRef: React.RefObject<HTMLDivElement>, lhsBadgeRefs: any, rhsBadgeRefs: any, proposedSections: any[], existingSections: any[]) => {
-    maintainRelativeOrder: boolean;
-    setMaintainRelativeOrder: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    isToggling: boolean;
-    setIsToggling: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    isSideBySide: boolean;
-    setIsSideBySide: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    isSideBySideLoading: boolean;
-    setIsSideBySideLoading: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    isArrowVisible: boolean;
-    setIsArrowVisible: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    expandedSections: Record<string, boolean>;
-    setExpandedSections: import("react").Dispatch<import("react").SetStateAction<Record<string, boolean>>>;
-    expandedSubSections: Record<string, boolean>;
-    setExpandedSubSections: import("react").Dispatch<import("react").SetStateAction<Record<string, boolean>>>;
-    activeSideBySideSection: string | number | null;
-    setActiveSideBySideSection: import("react").Dispatch<import("react").SetStateAction<string | number | null>>;
-    showDeviationNavigation: Record<string, any>;
-    scrollLock: import("react").MutableRefObject<boolean>;
-    isSideBySideRef: import("react").MutableRefObject<boolean>;
-    activeSideBySideSectionRef: import("react").MutableRefObject<string | number | null>;
-    activeSideBySideRightSectionRef: import("react").MutableRefObject<string | number | null>;
-};
-//# sourceMappingURL=useCompareLayout.d.ts.map

package/dist/types/src/features/CognitiveCompare/hooks/useCompareLayout.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useCompareLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/hooks/useCompareLayout.tsx"],"names":[],"mappings":";AAGA,eAAO,MAAM,gBAAgB,yBACL,OAAO,sBACT,MAAM,SAAS,CAAC,cAAc,CAAC,gBACrC,GAAG,gBACH,GAAG,oBACC,GAAG,EAAE,oBACL,GAAG,EAAE;;;;;;;;;;;;;;;;;;;;;;CAkFxB,CAAC"}

package/dist/types/src/features/CognitiveCompare/hooks/useComparePopups.d.ts

@@ -1,22 +0,0 @@
-import React from "react";
-import { SectionPopupState, PopupPosition, SummaryPopupState } from "../CognitiveCompareTypes";
-export declare const useComparePopups: (scrollContainerRef: React.RefObject<HTMLDivElement>) => {
-    cognitivePopup: SectionPopupState;
-    setCognitivePopup: React.Dispatch<React.SetStateAction<SectionPopupState>>;
-    moreFunctions: SectionPopupState;
-    setMoreFunctions: React.Dispatch<React.SetStateAction<SectionPopupState>>;
-    summaryPopup: SummaryPopupState;
-    setSummaryPopup: React.Dispatch<React.SetStateAction<SummaryPopupState>>;
-    closeSummaryPopup: () => void;
-    position: PopupPosition | null;
-    setPosition: React.Dispatch<React.SetStateAction<PopupPosition | null>>;
-    activeBadgeId: string | null;
-    setActiveBadgeId: React.Dispatch<React.SetStateAction<string | null>>;
-    popupRef: React.RefObject<HTMLDivElement>;
-    closeCognitivePopup: () => void;
-    closeMoreFunctionsPopup: () => void;
-    recalcPosition: () => void;
-    handleOpenCognitiveCompare: () => void;
-    openCognitivePopupFromState: (nextPopup: SectionPopupState) => void;
-};
-//# sourceMappingURL=useComparePopups.d.ts.map

package/dist/types/src/features/CognitiveCompare/hooks/useComparePopups.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useComparePopups.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/hooks/useComparePopups.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmD,MAAM,OAAO,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAG/F,eAAO,MAAM,gBAAgB,uBAAwB,MAAM,SAAS,CAAC,cAAc,CAAC;;;;;;;;;;;;;;;;;6CA2GlE,iBAAiB;CAuClC,CAAC"}

package/dist/types/src/features/CognitiveCompare/hooks/useDeviationNavigation.d.ts

@@ -1,32 +0,0 @@
-import React from "react";
-import { SectionBlock } from "../CognitiveCompareTypes";
-export type DeviationNavigationEntry = {
-    showAbove: boolean;
-    showAboveRef: React.RefObject<HTMLDivElement> | null;
-    showBelow: boolean;
-    showBelowRef: React.RefObject<HTMLDivElement> | null;
-    firstDeviationRef: React.RefObject<HTMLDivElement> | null;
-    firstDeviationPosition: "above" | "below" | "inside" | null;
-    columnKey: "left" | "right";
-};
-type UseDeviationNavigationParams = {
-    proposedSections: SectionBlock[];
-    existingSections: SectionBlock[];
-    parentDeviationRecord: Record<string, SectionBlock[]>;
-    expandedSections: Record<string, boolean>;
-    maintainRelativeOrder: boolean;
-    scrollContainerRef: React.RefObject<HTMLDivElement>;
-    leftContainerRef: React.RefObject<HTMLDivElement>;
-    rightContainerRef: React.RefObject<HTMLDivElement>;
-    lhsBadgeRefs: React.MutableRefObject<Record<string | number, React.RefObject<HTMLDivElement>>>;
-    rhsBadgeRefs: React.MutableRefObject<Record<string | number, React.RefObject<HTMLDivElement>>>;
-};
-export declare const useDeviationNavigation: ({ proposedSections, existingSections, parentDeviationRecord, expandedSections, maintainRelativeOrder, scrollContainerRef, leftContainerRef, rightContainerRef, lhsBadgeRefs, rhsBadgeRefs, }: UseDeviationNavigationParams) => {
-    showDeviationNavigation: Record<string, DeviationNavigationEntry>;
-    showOpenNodeRef: React.MutableRefObject<string | undefined>;
-    adjustScrollForPopup: (anchorEl: HTMLElement | null, onComplete: () => void, options?: {
-        skipScroll?: boolean;
-    }) => void;
-};
-export {};
-//# sourceMappingURL=useDeviationNavigation.d.ts.map

package/dist/types/src/features/CognitiveCompare/hooks/useDeviationNavigation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDeviationNavigation.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/hooks/useDeviationNavigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAmD,MAAM,OAAO,CAAC;AAExE,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC;IACrD,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC;IACrD,iBAAiB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC;IAC1D,sBAAsB,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,IAAI,CAAC;IAC5D,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;CAC7B,CAAC;AAEF,KAAK,4BAA4B,GAAG;IAClC,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IACtD,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,qBAAqB,EAAE,OAAO,CAAC;IAC/B,kBAAkB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;IACpD,gBAAgB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;IAClD,iBAAiB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;IACnD,YAAY,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAC/F,YAAY,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CAChG,CAAC;AAEF,eAAO,MAAM,sBAAsB,iMAWhC,4BAA4B;;;qCAyMjB,WAAW,GAAG,IAAI,cAChB,MAAM,IAAI,YACZ;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE;CA2ErC,CAAC"}

package/dist/types/src/features/CognitiveCompare/hooks/useLinesCalculator.d.ts

@@ -1,27 +0,0 @@
-/// <reference types="react" />
-export declare const useLinesCalculator: ({ containerRef, leftContainerRef, rightContainerRef, svgContainerRef, pathRefs, leftHeaderRef, rightHeaderRef, proposedSections, existingSections, visibleFields, leftRefs, rightRefs, sectionLeftRefs, sectionRightRefs, subSectionLeftRefs, subSectionRightRefs, lhsBadgeRefs, rhsBadgeRefs, sectionRowRefs, expandedSections, expandedSubSections, connectedSections, isSideBySide, activeSideBySideSection, maintainRelativeOrder, isGuidelineMode, cognitiveMap, getSectionCompareStyle, getSubSectionCompareStyle, getDeviationStyleByKey, isArrowVisible, isAnimatingRef, isSideBySideRef, sideBySideCacheRef, sideBySideLineRef, activeSideBySideSectionRef, activeSideBySideRightSectionRef, connectedLines: providedConnectedLines, setConnectedLines: providedSetConnectedLines, cachedConnectedPositions: providedCachedConnectedPositions, calculateLinesRef, resizeTimerRef, scrollLock, scrollSyncLocked, handleResizeRef, activeProposed, existingRule, analysisData, pendingScrollTargetRef, pendingScrollCallbackRef, resolvedComparisonConfig, getFieldData }: any) => {
-    lines: Record<string, any>[];
-    setLines: import("react").Dispatch<import("react").SetStateAction<Record<string, any>[]>>;
-    overallConnector: {
-        x1: number;
-        x2: number;
-        y: number;
-    } | null;
-    setOverallConnector: import("react").Dispatch<import("react").SetStateAction<{
-        x1: number;
-        x2: number;
-        y: number;
-    } | null>>;
-    connectedLines: any;
-    setConnectedLines: any;
-    svgDimensions: {
-        width: number;
-        height: number;
-    };
-    cachedConnectedPositions: any;
-    calculateLines: () => void;
-    calculateLinesRef: any;
-    calculateLinesDebounced: () => void;
-    handleColumnScroll: (e: any) => void;
-};
-//# sourceMappingURL=useLinesCalculator.d.ts.map

package/dist/types/src/features/CognitiveCompare/hooks/useLinesCalculator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useLinesCalculator.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/hooks/useLinesCalculator.tsx"],"names":[],"mappings":";AAKA,eAAO,MAAM,kBAAkB,qhCA2C5B,GAAG;;;;YAG6D,MAAM;YAAM,MAAM;WAAK,MAAM;;;YAA7B,MAAM;YAAM,MAAM;WAAK,MAAM;;;;;eAIhC,MAAM;gBAAU,MAAM;;;;;;4BA+2BrC,GAAG;CAiOnD,CAAA"}

package/dist/types/src/features/CognitiveCompare/hooks/useResizeHandler.d.ts

@@ -1,5 +0,0 @@
-export declare const useResizeHandler: ({ timerRef, ruleComponentRef, scrollContainerRef, containerRef, maintainRelativeOrder, proposedSections, existingSections, isSideBySideRef, activeSideBySideSectionRef, activeSideBySideRightSectionRef, sectionRowRefs, sectionRightRowRefs, sectionLeftRefs, sectionRightRefs, subSectionLeftRefs, subSectionRightRefs, lhsBadgeRefs, rhsBadgeRefs, leftContainerRef, rightContainerRef, calculateLinesRef, handleResizeRef: externalHandleResizeRef, setIsResizing, setIsArrowVisible, sideBySideCacheRef, cachedConnectedPositions }: any) => {
-    handleResize: () => void;
-    handleResizeRef: any;
-};
-//# sourceMappingURL=useResizeHandler.d.ts.map

package/dist/types/src/features/CognitiveCompare/hooks/useResizeHandler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useResizeHandler.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/hooks/useResizeHandler.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB,6gBA2B1B,GAAG;;;CA6NL,CAAA"}

package/dist/types/src/features/CognitiveCompare/hooks/useSectionRefs.d.ts

@@ -1,19 +0,0 @@
-import React from "react";
-import { DivRefMap } from "../CognitiveCompareTypes";
-export declare const useSectionRefs: (visibleFieldKeys: string[], sectionCount: number) => {
-    leftRefs: React.MutableRefObject<DivRefMap<string>>;
-    rightRefs: React.MutableRefObject<DivRefMap<string>>;
-    sectionLeftRefs: React.MutableRefObject<DivRefMap<string | number>>;
-    sectionRightRefs: React.MutableRefObject<DivRefMap<string | number>>;
-    lhsBadgeRefs: React.MutableRefObject<DivRefMap<string | number>>;
-    rhsBadgeRefs: React.MutableRefObject<DivRefMap<string | number>>;
-    sectionRightRowRefs: React.MutableRefObject<DivRefMap<string | number>>;
-    subSectionLeftRefs: React.MutableRefObject<DivRefMap<string>>;
-    subSectionRightRefs: React.MutableRefObject<DivRefMap<string>>;
-    sectionRowRefs: React.MutableRefObject<DivRefMap<string | number>>;
-    getFieldRef: (side: "left" | "right", key: string) => React.RefObject<HTMLDivElement>;
-    getSectionRowRef: (idx: string | number) => React.RefObject<HTMLDivElement>;
-    getSubSectionRef: (side: "left" | "right", keyPath: string) => React.RefObject<HTMLDivElement>;
-    getBadgeRef: (side: "left" | "right", key: string | number) => React.RefObject<HTMLDivElement>;
-};
-//# sourceMappingURL=useSectionRefs.d.ts.map

package/dist/types/src/features/CognitiveCompare/hooks/useSectionRefs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useSectionRefs.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/hooks/useSectionRefs.ts"],"names":[],"mappings":"AAAA,OAAO,KAA8B,MAAM,OAAO,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAMrD,eAAO,MAAM,cAAc,qBACP,MAAM,EAAE,gBACZ,MAAM;;;;;;;;;;;wBAcX,MAAM,GAAG,OAAO,OAAO,MAAM;4BAkC9B,MAAM,GAAG,MAAM;6BAKd,MAAM,GAAG,OAAO,WAAW,MAAM;wBAYjC,MAAM,GAAG,OAAO,OAAO,MAAM,GAAG,MAAM;CAuBhD,CAAC"}

package/dist/types/src/features/CognitiveCompare/hooks/useSideBySide.d.ts

@@ -1,35 +0,0 @@
-/// <reference types="react" />
-export declare const useSideBySide: ({ isGuidelineMode, maintainRelativeOrder, proposedSections, existingSections, leftContainerRef, rightContainerRef, scrollContainerRef, sectionLeftRefs, sectionRightRefs, subSectionLeftRefs, subSectionRightRefs, lhsBadgeRefs, rhsBadgeRefs, sectionRowRefs, sectionRightRowRefs, rhsTopSpacerRef, rhsBottomSpacerRef, lhsTopSpacerRef, lhsBottomSpacerRef, calculateLinesRef, setConnectedSections, setConnectedLines, cachedConnectedPositions, closeMoreFunctionsPopup, setErrorToast, moreFunctions, closeSummaryPopup, }: any) => {
-    isSideBySide: boolean;
-    setIsSideBySide: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    isArrowVisible: boolean;
-    setIsArrowVisible: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    isResizing: boolean;
-    setIsResizing: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    isSideBySideLoading: boolean;
-    setIsSideBySideLoading: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    activeSideBySideSection: string | number | null;
-    setActiveSideBySideSection: import("react").Dispatch<import("react").SetStateAction<string | number | null>>;
-    scrollLock: import("react").MutableRefObject<boolean>;
-    sideBySideCacheRef: import("react").MutableRefObject<{
-        badgeScreenY: number;
-        initialScrollTop: number;
-        leftTop: number;
-        leftBottom: number;
-        cTop: number;
-    } | null>;
-    isSideBySideRef: import("react").MutableRefObject<boolean>;
-    activeSideBySideSectionRef: import("react").MutableRefObject<string | number | null>;
-    activeSideBySideRightSectionRef: import("react").MutableRefObject<string | number | null>;
-    sideBySideLineRef: import("react").MutableRefObject<SVGLineElement | null>;
-    highlightedClauseRefs: import("react").MutableRefObject<Set<HTMLElement>>;
-    clearClauseHighlight: () => void;
-    applyAlignmentPadding: (isSub: boolean, idx: any, activeRightIdx: any) => void;
-    resetSideBySide: () => void;
-    activateSideBySide: (idx: number | string, isOrphan: boolean, options?: {
-        toggleIfSame?: boolean | undefined;
-        onReady?: (() => void) | undefined;
-        sourceSide?: "left" | "right" | undefined;
-    } | undefined) => void;
-};
-//# sourceMappingURL=useSideBySide.d.ts.map

package/dist/types/src/features/CognitiveCompare/hooks/useSideBySide.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useSideBySide.d.ts","sourceRoot":"","sources":["../../../../../../src/features/CognitiveCompare/hooks/useSideBySide.tsx"],"names":[],"mappings":";AAGA,eAAO,MAAM,aAAa,ogBAevB,GAAG;;;;;;;;;;;;;sBASgD,MAAM;0BAAoB,MAAM;iBAAW,MAAM;oBAAc,MAAM;cAAQ,MAAM;;;;;;;;mCAe/F,OAAO,OAAO,GAAG,kBAAkB,GAAG;;8BA2I/D,MAAM,GAAG,MAAM,YACV,OAAO;;yBACmC,IAAI;;;CAyPnE,CAAA"}

package/dist/types/src/features/CognitiveCompare/hooks/useStyles.d.ts

@@ -1,16 +0,0 @@
-import { ConflictBadgeStyleFn, SectionBlock, StyleVariant } from "../CognitiveCompareTypes";
-export declare const useStyleHelpers: ({ proposedSections, existingSections, maintainRelativeOrder, cognitiveMap, deviationData, treeData, resolvedComparisonConfig, badgeStyleOverride }: {
-    proposedSections: SectionBlock[];
-    existingSections: SectionBlock[];
-    maintainRelativeOrder: boolean;
-    cognitiveMap: any;
-    deviationData: any;
-    treeData: any;
-    resolvedComparisonConfig: any;
-    badgeStyleOverride?: ConflictBadgeStyleFn | undefined;
-}) => {
-    getSectionCompareStyle: (idx: number, side?: "left" | "right") => StyleVariant | null;
-    getSubSectionCompareStyle: (keyPath: string) => StyleVariant | null;
-    getDeviationStyleByKey: (nodeId: string, deviationKey: string) => StyleVariant | null;
-};
-//# sourceMappingURL=useStyles.d.ts.map