Save current BZZZ config-ui state before CHORUS branding update

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

install/config-ui/node_modules/axe-core/axe.d.ts

@@ -0,0 +1,628 @@
+// Type definitions for axe-core
+// Project: https://github.com/dequelabs/axe-core
+
+declare namespace axe {
+  type ImpactValue = 'minor' | 'moderate' | 'serious' | 'critical' | null;
+
+  type TagValue = string;
+
+  type ReporterVersion = 'v1' | 'v2' | 'raw' | 'rawEnv' | 'no-passes';
+
+  type RunOnlyType = 'rule' | 'rules' | 'tag' | 'tags';
+
+  type resultGroups = 'inapplicable' | 'passes' | 'incomplete' | 'violations';
+
+  type AriaAttrsType =
+    | 'boolean'
+    | 'nmtoken'
+    | 'mntokens'
+    | 'idref'
+    | 'idrefs'
+    | 'string'
+    | 'decimal'
+    | 'int';
+
+  type AriaRolesType = 'abstract' | 'widget' | 'structure' | 'landmark';
+
+  type DpubRolesType =
+    | 'section'
+    | 'landmark'
+    | 'link'
+    | 'listitem'
+    | 'img'
+    | 'navigation'
+    | 'note'
+    | 'separator'
+    | 'none'
+    | 'sectionhead';
+
+  type HtmlContentTypes =
+    | 'flow'
+    | 'sectioning'
+    | 'heading'
+    | 'phrasing'
+    | 'embedded'
+    | 'interactive';
+
+  // Array of length 2 or greater
+  type MultiArray<T> = [T, T, ...T[]];
+
+  // Selectors within a frame
+  type BaseSelector = string;
+
+  type ShadowDomSelector = MultiArray<BaseSelector>;
+  type CrossTreeSelector = BaseSelector | ShadowDomSelector;
+  type LabelledShadowDomSelector = { fromShadowDom: ShadowDomSelector };
+
+  // Cross-frame selectors
+  type FramesSelector = Array<CrossTreeSelector | LabelledShadowDomSelector>;
+  type UnlabelledFrameSelector = CrossTreeSelector[];
+  type LabelledFramesSelector = { fromFrames: MultiArray<FramesSelector[0]> };
+  /**
+   * @deprecated Use UnlabelledFrameSelector instead
+   */
+  type CrossFrameSelector = UnlabelledFrameSelector;
+
+  // Context options
+  type Selector =
+    | Node
+    | BaseSelector
+    | LabelledShadowDomSelector
+    | LabelledFramesSelector;
+  type SelectorList = Array<Selector | FramesSelector> | NodeList;
+  type ContextProp = Selector | SelectorList;
+  type ContextObject =
+    | {
+        include: ContextProp;
+        exclude?: ContextProp;
+      }
+    | {
+        exclude: ContextProp;
+        include?: ContextProp;
+      };
+  type ContextSpec = ContextProp | ContextObject;
+  /** Synonym to ContextSpec */
+  type ElementContext = ContextSpec;
+
+  type SerialSelector =
+    | BaseSelector
+    | LabelledShadowDomSelector
+    | LabelledFramesSelector;
+  type SerialFrameSelector = SerialSelector | FramesSelector;
+  type SerialSelectorList = Array<SerialFrameSelector>;
+
+  type SerialContextObject =
+    | {
+        include: SerialSelector | SerialSelectorList;
+        exclude?: SerialSelector | SerialSelectorList;
+      }
+    | {
+        exclude: SerialSelector | SerialSelectorList;
+        include?: SerialSelector | SerialSelectorList;
+      };
+
+  interface FrameContextObject {
+    include: UnlabelledFrameSelector[];
+    exclude: UnlabelledFrameSelector[];
+  }
+
+  type RunCallback<T = AxeResults> = (error: Error, results: T) => void;
+
+  interface TestEngine {
+    name: string;
+    version: string;
+  }
+  interface TestRunner {
+    name: string;
+  }
+  interface TestEnvironment {
+    userAgent: string;
+    windowWidth: number;
+    windowHeight: number;
+    orientationAngle?: number;
+    orientationType?: string;
+  }
+  interface RunOnly {
+    type: RunOnlyType;
+    values: TagValue[] | string[];
+  }
+  interface RuleObject {
+    [key: string]: {
+      enabled: boolean;
+    };
+  }
+  interface RunOptions {
+    runOnly?: RunOnly | TagValue[] | string[] | string;
+    rules?: RuleObject;
+    reporter?: ReporterVersion | string;
+    resultTypes?: resultGroups[];
+    selectors?: boolean;
+    ancestry?: boolean;
+    xpath?: boolean;
+    absolutePaths?: boolean;
+    iframes?: boolean;
+    elementRef?: boolean;
+    frameWaitTime?: number;
+    preload?: boolean | PreloadOptions;
+    performanceTimer?: boolean;
+    pingWaitTime?: number;
+  }
+  interface PreloadOptions {
+    assets: string[];
+    timeout?: number;
+  }
+  interface AxeResults extends EnvironmentData {
+    toolOptions: RunOptions;
+    passes: Result[];
+    violations: Result[];
+    incomplete: Result[];
+    inapplicable: Result[];
+  }
+  interface Result {
+    description: string;
+    help: string;
+    helpUrl: string;
+    id: string;
+    impact?: ImpactValue;
+    tags: TagValue[];
+    nodes: NodeResult[];
+  }
+  interface NodeResult {
+    html: string;
+    impact?: ImpactValue;
+    target: UnlabelledFrameSelector;
+    xpath?: string[];
+    ancestry?: UnlabelledFrameSelector;
+    any: CheckResult[];
+    all: CheckResult[];
+    none: CheckResult[];
+    failureSummary?: string;
+    element?: HTMLElement;
+  }
+  interface CheckResult {
+    id: string;
+    impact: string;
+    message: string;
+    data: any;
+    relatedNodes?: RelatedNode[];
+  }
+  interface RelatedNode {
+    html: string;
+    target: UnlabelledFrameSelector;
+    xpath?: string[];
+    ancestry?: UnlabelledFrameSelector;
+    element?: HTMLElement;
+  }
+  interface RuleLocale {
+    [key: string]: {
+      description: string;
+      help: string;
+    };
+  }
+  interface CheckMessages {
+    pass: string | { [key: string]: string };
+    fail: string | { [key: string]: string };
+    incomplete?: string | { [key: string]: string };
+  }
+  interface CheckLocale {
+    [key: string]: CheckMessages;
+  }
+  interface Locale {
+    lang?: string;
+    rules?: RuleLocale;
+    checks?: CheckLocale;
+  }
+  interface AriaAttrs {
+    type: AriaAttrsType;
+    values?: string[];
+    allowEmpty?: boolean;
+    global?: boolean;
+    unsupported?: boolean;
+  }
+  interface AriaRoles {
+    type: AriaRolesType | DpubRolesType;
+    requiredContext?: string[];
+    requiredOwned?: string[];
+    requiredAttrs?: string[];
+    allowedAttrs?: string[];
+    nameFromContent?: boolean;
+    unsupported?: boolean;
+  }
+  interface HtmlElmsVariant {
+    contentTypes?: HtmlContentTypes[];
+    allowedRoles: boolean | string[];
+    noAriaAttrs?: boolean;
+    shadowRoot?: boolean;
+    implicitAttrs?: { [key: string]: string };
+    namingMethods?: string[];
+  }
+  interface HtmlElms extends HtmlElmsVariant {
+    variant?: { [key: string]: HtmlElmsVariant };
+  }
+  interface Standards {
+    ariaAttrs?: { [key: string]: AriaAttrs };
+    ariaRoles?: { [key: string]: AriaRoles };
+    htmlElms?: { [key: string]: HtmlElms };
+    cssColors?: { [key: string]: number[] };
+  }
+  interface Spec {
+    branding?: string | Branding;
+    reporter?: ReporterVersion | string | AxeReporter;
+    checks?: Check[];
+    rules?: Rule[];
+    standards?: Standards;
+    locale?: Locale;
+    disableOtherRules?: boolean;
+    axeVersion?: string;
+    noHtml?: boolean;
+    allowedOrigins?: string[];
+    // Deprecated - do not use.
+    ver?: string;
+  }
+  /**
+   * @deprecated Use branding: string instead to set the application key in help URLs
+   */
+  interface Branding {
+    brand?: string;
+    application?: string;
+  }
+  interface CheckHelper {
+    async: () => (result: boolean | undefined | Error) => void;
+    data: (data: unknown) => void;
+    relatedNodes: (nodes: Element[]) => void;
+  }
+  interface AfterResult {
+    id: string;
+    data?: unknown;
+    relatedNodes: SerialDqElement[];
+    result: boolean | undefined;
+    node: SerialDqElement;
+  }
+  interface Check {
+    id: string;
+    evaluate?:
+      | string
+      | ((
+          this: CheckHelper,
+          node: Element,
+          options: unknown,
+          virtualNode: VirtualNode
+        ) => boolean | undefined | void);
+    after?:
+      | string
+      | ((results: AfterResult[], options: unknown) => AfterResult[]);
+    options?: any;
+    matches?: string;
+    enabled?: boolean;
+    metadata?: {
+      impact?: ImpactValue;
+      messages?: CheckMessages;
+    };
+  }
+  interface Rule {
+    id: string;
+    selector?: string;
+    impact?: ImpactValue;
+    excludeHidden?: boolean;
+    enabled?: boolean;
+    pageLevel?: boolean;
+    any?: string[];
+    all?: string[];
+    none?: string[];
+    tags?: string[];
+    matches?: string | ((node: Element, virtualNode: VirtualNode) => boolean);
+    reviewOnFail?: boolean;
+    actIds?: string[];
+    metadata?: Omit<RuleMetadata, 'ruleId' | 'tags' | 'actIds'>;
+  }
+  interface AxePlugin {
+    id: string;
+    run(...args: any[]): any;
+    commands: {
+      id: string;
+      callback(...args: any[]): void;
+    }[];
+    cleanup?(callback: Function): void;
+  }
+  interface RuleMetadata {
+    ruleId: string;
+    description: string;
+    help: string;
+    helpUrl: string;
+    tags: string[];
+    actIds?: string[];
+  }
+  interface SerialDqElement {
+    source: string;
+    nodeIndexes: number[];
+    selector: UnlabelledFrameSelector;
+    xpath: string[];
+    ancestry: UnlabelledFrameSelector;
+  }
+  interface DqElement extends SerialDqElement {
+    element: Element;
+    toJSON(): SerialDqElement;
+    mergeSpecs(
+      childSpec: SerialDqElement,
+      parentSpec: SerialDqElement
+    ): SerialDqElement;
+  }
+  interface PartialRuleResult {
+    id: string;
+    result: 'inapplicable';
+    pageLevel: boolean;
+    impact: null;
+    nodes: Array<Record<string, unknown>>;
+  }
+  interface PartialResult {
+    frames: SerialDqElement[];
+    results: PartialRuleResult[];
+    environmentData?: EnvironmentData;
+  }
+  type PartialResults = Array<PartialResult | null>;
+  interface FrameContext {
+    frameSelector: CrossTreeSelector;
+    frameContext: FrameContextObject;
+  }
+
+  interface RawCheckResult extends Omit<CheckResult, 'relatedNodes'> {
+    relatedNodes?: Array<SerialDqElement | DqElement>;
+  }
+
+  interface RawNodeResult<T extends 'passed' | 'failed' | 'incomplete'> {
+    node: SerialDqElement | DqElement;
+    any: RawCheckResult[];
+    all: RawCheckResult[];
+    none: RawCheckResult[];
+    impact: ImpactValue | null;
+    result: T;
+  }
+
+  interface RawResult extends Omit<Result, 'nodes'> {
+    inapplicable: Array<never>;
+    passes: RawNodeResult<'passed'>[];
+    incomplete: RawNodeResult<'incomplete'>[];
+    violations: RawNodeResult<'failed'>[];
+    pageLevel: boolean;
+    result: 'failed' | 'passed' | 'incomplete' | 'inapplicable';
+  }
+
+  type AxeReporter<T = unknown> = (
+    rawResults: RawResult[],
+    option: RunOptions,
+    resolve: (report: T) => void,
+    reject: (error: Error) => void
+  ) => void;
+
+  interface VirtualNode {
+    actualNode?: Node;
+    shadowId?: string;
+    children?: VirtualNode[];
+    parent?: VirtualNode;
+    attr(attr: string): string | null;
+    hasAttr(attr: string): boolean;
+    props: { [key: string]: unknown };
+    boundingClientRect: DOMRect;
+  }
+
+  interface Utils {
+    getFrameContexts: (
+      context?: ElementContext,
+      options?: RunOptions
+    ) => FrameContext[];
+    shadowSelect: (selector: CrossTreeSelector) => Element | null;
+    shadowSelectAll: (selector: CrossTreeSelector) => Element[];
+    getStandards(): Required<Standards>;
+    isContextSpec: (context: unknown) => context is ContextSpec;
+    isContextObject: (context: unknown) => context is ContextObject;
+    isContextProp: (context: unknown) => context is ContextProp;
+    isLabelledFramesSelector: (
+      selector: unknown
+    ) => selector is LabelledFramesSelector;
+    isLabelledShadowDomSelector: (
+      selector: unknown
+    ) => selector is LabelledShadowDomSelector;
+
+    DqElement: new (
+      elm: Element,
+      options?: { absolutePaths?: boolean }
+    ) => DqElement;
+    uuid: (
+      options?: { random?: Uint8Array | Array<number> },
+      buf?: Uint8Array | Array<number>,
+      offset?: number
+    ) => string | Uint8Array | Array<number>;
+  }
+
+  interface Aria {
+    getRoleType: (role: string | Element | VirtualNode | null) => string | null;
+  }
+
+  interface Dom {
+    isFocusable: (node: Element | VirtualNode) => boolean;
+    isNativelyFocusable: (node: Element | VirtualNode) => boolean;
+  }
+
+  type AccessibleTextOptions = {
+    inControlContext?: boolean;
+    inLabelledByContext?: boolean;
+  };
+
+  interface Text {
+    accessibleText: (
+      element: Element,
+      options?: AccessibleTextOptions
+    ) => string;
+  }
+
+  interface Commons {
+    aria: Aria;
+    dom: Dom;
+    text: Text;
+  }
+
+  interface EnvironmentData {
+    testEngine: TestEngine;
+    testRunner: TestRunner;
+    testEnvironment: TestEnvironment;
+    url: string;
+    timestamp: string;
+  }
+
+  let version: string;
+  let plugins: any;
+  let utils: Utils;
+  let commons: Commons;
+
+  /**
+   * Source string to use as an injected script in Selenium
+   */
+  let source: string;
+
+  /**
+   * Object for axe Results
+   */
+  var AxeResults: AxeResults;
+
+  /**
+   * Runs a number of rules against the provided HTML page and returns the resulting issue list
+   *
+   * @param   {ElementContext} context  Optional The `Context` specification object @see Context
+   * @param   {RunOptions}     options  Optional Options passed into rules or checks, temporarily modifying them.
+   * @param   {RunCallback}    callback Optional The function to invoke when analysis is complete.
+   * @returns {Promise<AxeResults>|void} If the callback was not defined, axe will return a Promise.
+   */
+  function run<T = AxeResults>(context?: ElementContext): Promise<T>;
+  function run<T = AxeResults>(options: RunOptions): Promise<T>;
+  function run<T = AxeResults>(
+    callback: (error: Error, results: T) => void
+  ): void;
+  function run<T = AxeResults>(
+    context: ElementContext,
+    callback: RunCallback<T>
+  ): void;
+  function run<T = AxeResults>(
+    options: RunOptions,
+    callback: RunCallback<T>
+  ): void;
+  function run<T = AxeResults>(
+    context: ElementContext,
+    options: RunOptions
+  ): Promise<T>;
+  function run<T = AxeResults>(
+    context: ElementContext,
+    options: RunOptions,
+    callback: RunCallback<T>
+  ): void;
+
+  /**
+   * Method for configuring the data format used by axe. Helpful for adding new
+   * rules, which must be registered with the library to execute.
+   * @param  {Spec}       Spec Object with valid `branding`, `reporter`, `checks` and `rules` data
+   */
+  function configure(spec: Spec): void;
+
+  /**
+   * Run axe in the current window only
+   * @param   {ElementContext} context  Optional The `Context` specification object @see Context
+   * @param   {RunOptions}     options  Optional Options passed into rules or checks, temporarily modifying them.
+   * @returns {Promise<PartialResult>}  Partial result, for use in axe.finishRun.
+   */
+  function runPartial(
+    context: ElementContext,
+    options: RunOptions
+  ): Promise<PartialResult>;
+
+  /**
+   * Create a report from axe.runPartial results
+   * @param   {PartialResult[]}     partialResults  Results from axe.runPartial, calls in different frames on the page.
+   * @param   {RunOptions}     options  Optional Options passed into rules or checks, temporarily modifying them.
+   */
+  function finishRun(
+    partialResults: PartialResults,
+    options: RunOptions
+  ): Promise<AxeResults>;
+
+  /**
+   * Searches and returns rules that contain a tag in the list of tags.
+   * @param  {Array}  tags  Optional array of tags
+   * @return {Array}  Array of rules
+   */
+  function getRules(tags?: string[]): RuleMetadata[];
+
+  /**
+   * Restores the default axe configuration
+   */
+  function reset(): void;
+
+  /**
+   * Function to register a plugin configuration in document and its subframes
+   * @param  {Object}    plugin    A plugin configuration object
+   */
+  function registerPlugin(plugin: AxePlugin): void;
+
+  /**
+   * Function to clean up plugin configuration in document and its subframes
+   */
+  function cleanup(): void;
+
+  /**
+   * Set up alternative frame communication
+   */
+  function frameMessenger(frameMessenger: FrameMessenger): void;
+
+  /**
+   * Setup axe-core so axe.common functions can work properly.
+   */
+  function setup(node?: Element | Document): VirtualNode;
+
+  /**
+   * Clean up axe-core tree and caches. `axe.run` will call this function at the end of the run so there's no need to call it yourself afterwards.
+   */
+  function teardown(): void;
+
+  /**
+   * Check if a reporter is registered
+   */
+  function hasReporter(reporterName: string): boolean;
+
+  /**
+   * Get a reporter based the name it is registered with
+   */
+  function getReporter<T>(reporterName: string): AxeReporter<T>;
+
+  /**
+   * Register a new reporter, optionally setting it as the default
+   */
+  function addReporter<T>(
+    reporterName: string,
+    reporter: AxeReporter<T>,
+    isDefault?: boolean
+  ): void;
+
+  // axe.frameMessenger
+  type FrameMessenger = {
+    open: (topicHandler: TopicHandler) => Close | void;
+    post: (
+      frameWindow: Window,
+      data: TopicData,
+      replyHandler: ReplyHandler
+    ) => boolean | void;
+  };
+  type Close = Function;
+  type TopicHandler = (data: TopicData, responder: Responder) => void;
+  type ReplyHandler = (
+    message: any | Error,
+    keepalive: boolean,
+    responder: Responder
+  ) => void;
+  type Responder = (
+    message: any | Error,
+    keepalive?: boolean,
+    replyHandler?: ReplyHandler
+  ) => void;
+  type TopicData = { topic: string } & ReplyData;
+  type ReplyData = { channelId: string; message: any; keepalive: boolean };
+}
+
+export = axe;