@pb33f/cowboy-components 0.7.18 → 0.8.0

package/dist/events/doctor.d.ts

@@ -1,15 +1,17 @@
 import { ProblemItem } from "../components/problem-list/problem-item.js";
+import { Problem } from "../model/problem.js";
 import { RuleComponent } from "../components/manage-ruleset/rule.js";
 import { RuleAction, RuleConfig, RuleSet } from "../model/vacuum_rule.js";
 import { Toast } from "../model/toast.js";
-import { RuleActionComponent } from "../components/manage-ruleset/rule-action";
-import { GraphResponse, Node, References, Spacing, Options, Change } from "../model/graph";
-import { SpecSummary } from "../model/timeline";
-import { AuthenticationState } from "../model/auth";
+import { RuleActionComponent } from "../components/manage-ruleset/rule-action.js";
+import { GraphResponse, Node, Spacing, Change } from "../model/graph.js";
+import { SpecSummary, ChangeStatisticsResponse } from "../model/timeline.js";
+import { AuthenticationState } from "../model/auth.js";
 export declare const EditorUpdated: string;
 export declare const EditorClicked: string;
 export declare const ProblemClicked: string;
-export declare const OpenProblemDrawer: string;
+export declare const BrokerConnected: string;
+export declare const SocketDisconnected: string;
 export declare const MainViewSlideChanged: string;
 export declare const ProblemLabelViewFilterChanged: string;
 export declare const ProblemSortFilterChanged: string;
@@ -48,6 +50,10 @@ export declare const ExplorerKeyClose: string;
 export declare const ExplorerEqualizerChanged: string;
 export declare const ExplorerEqualizerFiltered: string;
 export declare const ExplorerDependentNodeClicked: string;
+export declare const ExplorerLoadMoreChildren: string;
+export declare const ExplorerPovModeClicked: string;
+export declare const ExplorerPovModeExit: string;
+export declare const ExplorerPovAncestorsToggle: string;
 export declare const ArchiveURLRequested: string;
 export declare const DocumentReferenceClicked: string;
 export declare const LoadRenderedNodeIntoInspector: string;
@@ -57,6 +63,7 @@ export declare const AuthenticationStateChange = "authenticationStateChange";
 export declare const LogoutRequested = "logoutRequested";
 export declare const TimelineHistoryRefresh = "timelineHistoryRefresh";
 export declare const RevisionClicked = "revisionClicked";
+export declare const TimelineViolationsLoaded = "timelineViolationsLoaded";
 export declare const ShowTimelineSummary = "showTimelineSummary";
 export declare const OpenSettings = "openSettings";
 export declare const OpenAuthentication = "openAuthentication";
@@ -71,14 +78,40 @@ export declare const SwitchWorkspace = "switchWorkspace";
 export declare const DeleteWorkspace = "deleteWorkspace";
 export declare const CreateWorkspace = "createWorkspace";
 export declare const UpdateWorkspace = "updateWorkspace";
+export declare const DiagramRequested: string;
+export declare const OpenDrawer: string;
 export declare const DailyCreditRequested = "dailyCreditRequested";
 export declare const DailyCreditApplied = "dailyCreditApplied";
 export declare const CreditStreamUpdated = "creditStreamUpdated";
 export declare const DailyCreditErrorChanged = "dailyCreditErrorChanged";
 export declare const Reboot = "reboot";
+export declare const GitHubInstallationsLoaded = "github-installations-loaded";
+export declare const GitHubRepositoriesLoaded = "github-repositories-loaded";
+export declare const GitHubRepositoryClaimed = "github-repository-claimed";
+export declare const GitHubRepositoryAttached = "github-repository-attached";
+export declare const GitHubClaimRepository = "github-claim-repository";
+export declare const GitHubAttachRepository = "github-attach-repository";
+export declare const GitHubRefreshInstallations = "github-refresh-installations";
+export declare const GitHubRefreshRepositories = "github-refresh-repositories";
+export declare const GitHubRepositoriesAsync = "github-repositories-async";
+export declare const GitHubInstallationsAsync = "github-installations-async";
+export declare const GitHubCacheLoaded = "github-cache-loaded";
+export declare const ImportedRepoFileHoverOver = "imported-repo-file-hover-over";
+export declare const ImportedRepoFileHoverOut = "imported-repo-file-hover-out";
+export declare const LinkedWorkspaceHoverOver = "linked-workspace-hover-over";
+export declare const LinkedWorkspaceHoverOut = "linked-workspace-hover-out";
+export declare const BundleRequested = "bundleRequested";
+export declare const BundleCompleted = "bundleCompleted";
+export declare const BundleDownloadRequested = "bundleDownloadRequested";
+export declare const BundleCopyRequested = "bundleCopyRequested";
 export interface RevisionClickedEvent {
     specSummary: SpecSummary;
 }
+export interface TimelineViolationsLoadedEvent {
+    violations: Problem[];
+    statistics: ChangeStatisticsResponse;
+    changeId: string;
+}
 export interface NukeLogout {
     resetFiles: boolean;
 }
@@ -93,11 +126,17 @@ export interface ExplorerDependentNodeClickedEvent {
     node: Node;
     collapse: boolean;
 }
+export interface ExplorerLoadMoreChildrenEvent {
+    parentId: string;
+}
+export interface ExplorerPovModeClickedEvent {
+    nodeId: string;
+}
 export interface ExplorerEqualizerChangedEvent {
     graph: GraphResponse;
     spacing?: Spacing;
-    references?: References;
-    options?: Options;
+    povMode?: boolean;
+    povNodeId?: string;
 }
 export interface DocumentReference {
     jsonPath: string;
@@ -109,6 +148,7 @@ export interface LoadRenderedNodeIntoInspectorEvent {
 export interface NodeReferenceEvent {
     nodePath: string;
 }
+export type NodeClickSource = 'user' | 'timeline' | 'programmatic';
 export interface NodeClickedEvent {
     nodeHashId?: string;
     nodeId?: string;
@@ -119,6 +159,7 @@ export interface NodeClickedEvent {
     line?: number;
     column?: number;
     changes?: Change[];
+    source?: NodeClickSource;
 }
 export interface ProblemLabelViewFilterChangedEvent {
     label: string;
@@ -196,17 +237,30 @@ export interface AddToastEvent {
 export declare enum ActiveView {
     Problems = "problems",
     Overview = "overview",
-    Ruleset = "ruleset"
+    Ruleset = "ruleset",
+    Tardis = "tardis"
 }
 export interface HistoryState {
     rule: string;
     page: number;
     view: ActiveView;
-    activeNode: string;
+    activeNodeId?: string;
+    activeNode?: string;
     ref: string;
 }
+export interface DiagramRequestedEvent {
+    nodeId: string;
+    jsonPath: string;
+    nodeType?: string;
+    title?: string;
+}
 export interface FormFieldChangeEvent {
     key: string;
     value: any;
     originalValue: any;
 }
+export interface BundleCompletedEvent {
+    bundledSpec: string;
+    bundleId: string;
+    cached: boolean;
+}

package/dist/events/doctor.js

@@ -1,7 +1,8 @@
 export const EditorUpdated = "editorUpdated";
 export const EditorClicked = "editorClicked";
 export const ProblemClicked = "problemClicked";
-export const OpenProblemDrawer = "openProblemDrawer";
+export const BrokerConnected = "brokerConnected";
+export const SocketDisconnected = "socketDisconnected";
 export const MainViewSlideChanged = "mainViewSlideChanged";
 export const ProblemLabelViewFilterChanged = "problemLabelViewFilterChanged";
 export const ProblemSortFilterChanged = "problemSortFilterChanged";
@@ -40,6 +41,10 @@ export const ExplorerKeyClose = "explorerKeyClose";
 export const ExplorerEqualizerChanged = "explorerEqualizerChanged";
 export const ExplorerEqualizerFiltered = "explorerEqualizerFiltered";
 export const ExplorerDependentNodeClicked = "explorerDependentNodeClicked";
+export const ExplorerLoadMoreChildren = "explorerLoadMoreChildren";
+export const ExplorerPovModeClicked = "explorerPovModeClicked";
+export const ExplorerPovModeExit = "explorerPovModeExit";
+export const ExplorerPovAncestorsToggle = "explorerPovAncestorsToggle";
 export const ArchiveURLRequested = "archiveURLRequested";
 export const DocumentReferenceClicked = "documentReferenceClicked";
 export const LoadRenderedNodeIntoInspector = "loadRenderedNodeIntoInspector";
@@ -49,6 +54,7 @@ export const AuthenticationStateChange = "authenticationStateChange";
 export const LogoutRequested = "logoutRequested";
 export const TimelineHistoryRefresh = "timelineHistoryRefresh";
 export const RevisionClicked = "revisionClicked";
+export const TimelineViolationsLoaded = "timelineViolationsLoaded";
 export const ShowTimelineSummary = "showTimelineSummary";
 export const OpenSettings = "openSettings";
 export const OpenAuthentication = "openAuthentication";
@@ -63,14 +69,36 @@ export const SwitchWorkspace = 'switchWorkspace';
 export const DeleteWorkspace = 'deleteWorkspace';
 export const CreateWorkspace = 'createWorkspace';
 export const UpdateWorkspace = 'updateWorkspace';
+export const DiagramRequested = "diagramRequested";
+export const OpenDrawer = "openDrawer";
 export const DailyCreditRequested = 'dailyCreditRequested';
 export const DailyCreditApplied = 'dailyCreditApplied';
 export const CreditStreamUpdated = 'creditStreamUpdated';
 export const DailyCreditErrorChanged = 'dailyCreditErrorChanged';
 export const Reboot = 'reboot';
+export const GitHubInstallationsLoaded = 'github-installations-loaded';
+export const GitHubRepositoriesLoaded = 'github-repositories-loaded';
+export const GitHubRepositoryClaimed = 'github-repository-claimed';
+export const GitHubRepositoryAttached = 'github-repository-attached';
+export const GitHubClaimRepository = 'github-claim-repository';
+export const GitHubAttachRepository = 'github-attach-repository';
+export const GitHubRefreshInstallations = 'github-refresh-installations';
+export const GitHubRefreshRepositories = 'github-refresh-repositories';
+export const GitHubRepositoriesAsync = 'github-repositories-async';
+export const GitHubInstallationsAsync = 'github-installations-async';
+export const GitHubCacheLoaded = 'github-cache-loaded';
+export const ImportedRepoFileHoverOver = 'imported-repo-file-hover-over';
+export const ImportedRepoFileHoverOut = 'imported-repo-file-hover-out';
+export const LinkedWorkspaceHoverOver = 'linked-workspace-hover-over';
+export const LinkedWorkspaceHoverOut = 'linked-workspace-hover-out';
+export const BundleRequested = 'bundleRequested';
+export const BundleCompleted = 'bundleCompleted';
+export const BundleDownloadRequested = 'bundleDownloadRequested';
+export const BundleCopyRequested = 'bundleCopyRequested';
 export var ActiveView;
 (function (ActiveView) {
     ActiveView["Problems"] = "problems";
     ActiveView["Overview"] = "overview";
     ActiveView["Ruleset"] = "ruleset";
+    ActiveView["Tardis"] = "tardis";
 })(ActiveView || (ActiveView = {}));

package/dist/events/drawer-events.d.ts

@@ -0,0 +1,7 @@
+export declare const DrawerEvents: {
+    readonly TOGGLE_WIDTH: "drawer-toggle-width";
+};
+export type DrawerWidthMode = 'full' | '75' | 'half' | 'default';
+export interface DrawerToggleWidthDetail {
+    width: DrawerWidthMode;
+}

package/dist/events/drawer-events.js

@@ -0,0 +1,3 @@
+export const DrawerEvents = {
+    TOGGLE_WIDTH: 'drawer-toggle-width'
+};

package/dist/events/theme.d.ts

@@ -0,0 +1,4 @@
+export declare const PB33F_THEME_CHANGE = "pb33f-theme-change";
+export interface ThemeChangeDetail {
+    theme: 'dark' | 'light';
+}

package/dist/events/theme.js

@@ -0,0 +1 @@
+export const PB33F_THEME_CHANGE = 'pb33f-theme-change';

package/dist/factories/explorer-component-factory.d.ts

@@ -0,0 +1,49 @@
+import { ElkNode } from 'elkjs';
+import { Edge, GraphResponse, Node, VacuumResult } from '../model/graph.js';
+import { GraphNodeComponent } from '../components/visualizer/nodes/graph-node.js';
+import { ForeignObjectComponent } from '../components/visualizer/foreign-object.js';
+import { EdgeComponent } from '../components/visualizer/edge.js';
+import { ExplorerNode, ExplorerEdge } from '../components/visualizer/explorer.js';
+export interface ExplorerComponentFactoryDeps {
+    getNodeMap: () => Map<string, Node>;
+    getDefinitionCache: () => Map<string, Node>;
+    getEdgeMap: () => Map<string, Edge>;
+}
+export interface BuildNodesContext {
+    graph: ElkNode;
+    graphResponse: GraphResponse;
+    expandedNodes: Set<string>;
+    hasMoreChildren: Map<string, number>;
+    povMode: boolean;
+    povNodeId: string | null;
+    activeNode: Node | undefined;
+    violationMap: Map<string, VacuumResult>;
+}
+export interface BuildNodesResult {
+    nodes: ExplorerNode[];
+    nodeComponents: ForeignObjectComponent[];
+    renderGraphMap: Map<string, GraphNodeComponent>;
+    nodeComponentMap: Map<string, ForeignObjectComponent>;
+}
+export interface BuildEdgesContext {
+    graph: ElkNode;
+    collapsedEdges: Map<string, boolean>;
+    bendPoints: boolean;
+    bendEdges: boolean;
+    nodeLimitExceeded: boolean;
+    povMode: boolean;
+}
+export interface BuildEdgesResult {
+    edges: ExplorerEdge[];
+    edgeComponents: EdgeComponent[];
+    edgeComponentMap: Map<string, EdgeComponent>;
+}
+export declare class ExplorerComponentFactory {
+    private readonly deps;
+    constructor(deps: ExplorerComponentFactoryDeps);
+    createNodeComponent(nodeType: string): GraphNodeComponent;
+    buildNodes(ctx: BuildNodesContext): BuildNodesResult;
+    buildEdges(ctx: BuildEdgesContext, renderGraphMap: Map<string, GraphNodeComponent>): BuildEdgesResult;
+    private resolveNodeInstance;
+    private applyLeafDetection;
+}

package/dist/factories/explorer-component-factory.js

@@ -0,0 +1,205 @@
+import { NodeType } from '../model/node_type.js';
+import { GraphNodeComponent } from '../components/visualizer/nodes/graph-node.js';
+import { DocumentNodeComponent } from '../components/visualizer/nodes/document.js';
+import { InfoNodeComponent } from '../components/visualizer/nodes/info.js';
+import { LicenseNodeComponent } from '../components/visualizer/nodes/license.js';
+import { ContactNodeComponent } from '../components/visualizer/nodes/contact.js';
+import { TagNodeComponent } from '../components/visualizer/nodes/tag.js';
+import { ServerNodeComponent } from '../components/visualizer/nodes/server.js';
+import { ComponentsNodeComponent } from '../components/visualizer/nodes/components.js';
+import { SchemaNodeComponent } from '../components/visualizer/nodes/schema.js';
+import { SecuritySchemeNodeComponent } from '../components/visualizer/nodes/security-scheme.js';
+import { ParameterNodeComponent } from '../components/visualizer/nodes/parameter.js';
+import { HeaderNodeComponent } from '../components/visualizer/nodes/header.js';
+import { RequestBodyNodeComponent } from '../components/visualizer/nodes/request-body.js';
+import { MediaTypeNodeComponent } from '../components/visualizer/nodes/media-type.js';
+import { ResponseNodeComponent } from '../components/visualizer/nodes/response.js';
+import { LinkNodeComponent } from '../components/visualizer/nodes/link.js';
+import { CallbackNodeComponent } from '../components/visualizer/nodes/callback.js';
+import { PathItemNodeComponent } from '../components/visualizer/nodes/path-item.js';
+import { OperationNodeComponent } from '../components/visualizer/nodes/operation.js';
+import { XMLNodeComponent } from '../components/visualizer/nodes/xml.js';
+import { ForeignObjectComponent } from '../components/visualizer/foreign-object.js';
+import { EdgeComponent } from '../components/visualizer/edge.js';
+export class ExplorerComponentFactory {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    createNodeComponent(nodeType) {
+        const nodeMap = this.deps.getNodeMap();
+        switch (nodeType) {
+            case NodeType.DOCUMENT:
+                return new DocumentNodeComponent(nodeMap);
+            case NodeType.INFO:
+                return new InfoNodeComponent(nodeMap);
+            case NodeType.LICENSE:
+                return new LicenseNodeComponent(nodeMap);
+            case NodeType.CONTACT:
+                return new ContactNodeComponent(nodeMap);
+            case NodeType.TAG:
+                return new TagNodeComponent(nodeMap);
+            case NodeType.SERVER:
+                return new ServerNodeComponent(nodeMap);
+            case NodeType.COMPONENTS:
+                return new ComponentsNodeComponent(nodeMap);
+            case NodeType.SCHEMA:
+                return new SchemaNodeComponent(nodeMap);
+            case NodeType.SECURITY_SCHEME:
+                return new SecuritySchemeNodeComponent(nodeMap);
+            case NodeType.PARAMETER:
+                return new ParameterNodeComponent(nodeMap);
+            case NodeType.HEADER:
+                return new HeaderNodeComponent(nodeMap);
+            case NodeType.REQUEST_BODY:
+                return new RequestBodyNodeComponent(nodeMap);
+            case NodeType.MEDIA_TYPE:
+                return new MediaTypeNodeComponent(nodeMap);
+            case NodeType.RESPONSE:
+                return new ResponseNodeComponent(nodeMap);
+            case NodeType.LINK:
+                return new LinkNodeComponent(nodeMap);
+            case NodeType.CALLBACK:
+                return new CallbackNodeComponent(nodeMap);
+            case NodeType.PATH_ITEM:
+                return new PathItemNodeComponent(nodeMap);
+            case NodeType.OPERATION:
+                return new OperationNodeComponent(nodeMap);
+            case NodeType.XML:
+                return new XMLNodeComponent(nodeMap);
+            default:
+                return new GraphNodeComponent(nodeMap);
+        }
+    }
+    buildNodes(ctx) {
+        const nodes = [];
+        const nodeComponents = [];
+        const renderGraphMap = new Map();
+        const nodeComponentMap = new Map();
+        const nodeMap = this.deps.getNodeMap();
+        const definitionCache = this.deps.getDefinitionCache();
+        ctx.graphResponse.nodes?.forEach((node) => {
+            nodeMap.set(node.id, node);
+            if (node.instance && typeof node.instance === 'object' && !node.instance.$ref) {
+                definitionCache.set(node.id, node);
+            }
+        });
+        ctx.graphResponse.edges?.forEach((edge) => {
+            this.deps.getEdgeMap().set(edge.id, edge);
+        });
+        ctx.graph.children?.forEach((c) => {
+            const child = c;
+            if (child.x && child.y) {
+                child.x = Math.round(child.x);
+                child.y = Math.round(child.y);
+            }
+            const op = this.createNodeComponent(child.type);
+            op.height = child.height;
+            op.width = child.width - 2;
+            op.id = child.id;
+            op.label = child.label;
+            op.isLeaf = !(child.nodes && child.nodes.length > 0);
+            op.expanded = ctx.expandedNodes.has(child.id);
+            op.moreChildrenCount = ctx.hasMoreChildren.get(child.id) || 0;
+            op.node = child;
+            op.inPovMode = ctx.povMode;
+            op.povNodeId = ctx.povNodeId;
+            const sourceNode = nodeMap.get(child.id);
+            op.nodeInstance = this.resolveNodeInstance(child, definitionCache.get(child.id), sourceNode);
+            op.violationMap = ctx.violationMap;
+            child.violationIds = sourceNode?.violationIds;
+            const isDependency = sourceNode?.dependency || false;
+            op.isDependency = isDependency;
+            op.dim = isDependency && ctx.povMode;
+            const isActive = ctx.activeNode && ctx.activeNode.id === child.id;
+            if (isActive) {
+                op.active = true;
+            }
+            renderGraphMap.set(child.id, op);
+            const nc = new ForeignObjectComponent();
+            const config = {
+                id: child.id,
+                x: child.x,
+                y: child.y,
+                width: child.width,
+                height: child.height,
+                body: op,
+                active: isActive,
+                visible: true
+            };
+            nc.configure(config);
+            nodeComponents.push(nc);
+            nodeComponentMap.set(child.id, nc);
+            nodes.push(child);
+        });
+        return { nodes, nodeComponents, renderGraphMap, nodeComponentMap };
+    }
+    buildEdges(ctx, renderGraphMap) {
+        const edges = [];
+        const edgeComponents = [];
+        const edgeComponentMap = new Map();
+        const edgeMap = this.deps.getEdgeMap();
+        const disableAnimations = ctx.nodeLimitExceeded ||
+            (ctx.graph.children && ctx.graph.children.length > 500);
+        ctx.graph.edges?.forEach((e) => {
+            const edge = e;
+            const s = renderGraphMap.get(edge.sources[0]);
+            s?.outputs.push(edge);
+            const t = renderGraphMap.get(edge.targets[0]);
+            t?.inputs.push(edge);
+            if (edge.ref.length > 0 && s) {
+                s.isRef = true;
+            }
+            const edgeComponent = new EdgeComponent();
+            const sourceEdge = edgeMap.get(edge.id);
+            const isDependency = sourceEdge?.dependency || false;
+            const config = {
+                edge: edge,
+                visible: !ctx.collapsedEdges.has(edge.id),
+                animated: !disableAnimations,
+                bendPoints: ctx.bendPoints,
+                bendCurve: ctx.bendEdges,
+                isDependency: isDependency,
+                dim: isDependency && ctx.povMode
+            };
+            edgeComponent.configure(config);
+            edges.push(edge);
+            edgeComponents.push(edgeComponent);
+            edgeComponentMap.set(edge.id, edgeComponent);
+        });
+        this.applyLeafDetection(renderGraphMap, edgeComponentMap);
+        return { edges, edgeComponents, edgeComponentMap };
+    }
+    resolveNodeInstance(child, definition, sourceNode) {
+        const childHasRealInstance = child.instance &&
+            typeof child.instance === 'object' &&
+            !child.instance.$ref;
+        if (childHasRealInstance) {
+            return child.instance;
+        }
+        return definition?.instance || sourceNode?.instance;
+    }
+    applyLeafDetection(renderGraphMap, edgeComponentMap) {
+        renderGraphMap.forEach((node) => {
+            if (node.outputs.length <= 0) {
+                node.inputs.forEach((edge) => {
+                    const e = edgeComponentMap.get(edge.id);
+                    if (e) {
+                        e.targetIsLeaf = true;
+                    }
+                });
+            }
+            else {
+                node.outputs.forEach((edge) => {
+                    if (edge.ref !== '') {
+                        const e = edgeComponentMap.get(edge.id);
+                        if (e && e.targetIsLeaf) {
+                            e.targetIsLeaf = false;
+                            node.isLeaf = false;
+                            node.isRef = true;
+                        }
+                    }
+                });
+            }
+        });
+    }
+}

package/dist/factories/state-controller-deps.factory.d.ts

@@ -0,0 +1,88 @@
+import type { Bag } from "@pb33f/saddlebag";
+import type { StateControllerDeps } from "../interfaces/doctor-interfaces.js";
+import type { Problem } from "../model/problem.js";
+import type { DrDiagnostics } from "../model/document-statistics.js";
+import type { GraphResponse, Node, Reference } from "../model/graph.js";
+import type { RenderMap, RuleConfig, RuleSet } from "../model/vacuum_rule.js";
+import type { DoctorConfiguration } from "../model/settings.js";
+import type { RolodexResponse, RolodexState, ReferenceMap } from "../model/rolodex.js";
+import type { PanelState } from "../model/panel-state.js";
+export interface StateControllerDepsHost {
+    settingsBag: Bag<DoctorConfiguration> | undefined;
+    rolodexResponseBag: Bag<RolodexResponse> | undefined;
+    rolodexStateBag: Bag<RolodexState> | undefined;
+    referenceMapBag: Bag<ReferenceMap> | undefined;
+    docBag: Bag<string> | undefined;
+    graphBag: Bag<GraphResponse> | undefined;
+    panelStateBag: Bag<PanelState> | undefined;
+    problemBag: Bag<Problem[]> | undefined;
+    howToFixBag: Bag<any> | undefined;
+    diagnosticBag: Bag<DrDiagnostics> | undefined;
+    defaultRulesetBag: Bag<RuleSet> | undefined;
+    OWASPRulesetBag: Bag<RuleSet> | undefined;
+    allRulesetBag: Bag<RuleSet> | undefined;
+    functionsBag: Bag<any> | undefined;
+    functionSchemaBag: Bag<any> | undefined;
+    customRulesetBag: Bag<RuleSet> | undefined;
+    ruleConfigBag: Bag<RuleConfig> | undefined;
+    sessionRulesetMapBag: Bag<RenderMap> | undefined;
+    sessionRulesetYamlBag: Bag<string> | undefined;
+    readonly editor: any;
+    readonly rulesetEditor: any;
+    readonly rolodexTree: any;
+    readonly modelTree: any;
+    readonly explorer: any;
+    readonly problemList: any;
+    readonly problemsOverview: any;
+    readonly manageRuleset: any;
+    readonly settingsComponent: any;
+    readonly splitPanelExplorer: {
+        position: number;
+    } | null;
+    readonly splitPanelInspector: {
+        position: number;
+    } | null;
+    readonly modelController: {
+        extractGraph(graph: GraphResponse): void;
+        fetchRefMap(path?: string): void;
+    };
+    readonly specController: {
+        updateProblems(problems: Problem[]): void;
+    };
+    readonly rolodexController: {
+        buildRolodexResultMap(problems: Problem[]): Map<string, Problem[]>;
+        queryRolodex(path?: string): void;
+    };
+    readonly ruleController: {
+        fetchDefaultRuleset(): Promise<RuleSet>;
+        fetchOWASPRuleset(): Promise<RuleSet>;
+        fetchAllRuleset(): Promise<RuleSet>;
+        fetchSessionRulesetAsYaml(): Promise<string>;
+        fetchRulesetMap(): void;
+    };
+    readonly docsController: {
+        fetchDocs(): void;
+    };
+    readonly bagManager: {
+        getBag<T>(key: string): Bag<T> | undefined;
+    };
+    rolodexDividerPosition: number;
+    rolodexActivePath: string | undefined;
+    rolodexActiveHash: string | undefined;
+    rolodexRoot: Node | null;
+    rolodexRootPath: string;
+    rolodexRootHash: string;
+    rolodexNeedsReset: boolean;
+    readonly rolodexProblemMap: Map<string, Problem[]>;
+    references: Reference[];
+    problems: Problem[];
+    defaultRuleset: RuleSet | undefined;
+    OWASPRuleset: RuleSet | undefined;
+    allRuleset: RuleSet | undefined;
+    functions: string[] | undefined;
+    customRuleset: RuleSet | undefined;
+    settingsChanged(key: string, settings: any): void;
+    platformUnavailable(error: any): void;
+    requestUpdate(): void;
+}
+export declare function createStateControllerDeps(host: StateControllerDepsHost): StateControllerDeps;