@hubspot/ui-extensions-sdk-api-metadata 0.11.6 → 0.12.1

package/dist/internal/render-prop-type.js

@@ -0,0 +1,325 @@
+import { isArrayNode, isBuiltInTypeReferenceNode, isExternalTypeReferenceNode, isFunctionNode, isIntersectionNode, isLiteralNode, isObjectNode, isPrimitiveNode, isTupleNode, isTypeReferenceNode, isUnionNode, } from '@hubspot/ts-export-types-reader';
+import { wrapCodeInHtmlCodeTags } from "./utils/jsx-utils.js";
+/**
+ * Renders an index signature node as a string representation.
+ *
+ * Converts an IndexSignatureNode into a TypeScript-like index signature string, e.g.:
+ * `[key: string]: any` or `readonly [key: number]: string`
+ *
+ * @param context - The rendering context containing the types reader
+ * @param indexSignature - The index signature node to render
+ * @returns A string representation of the index signature
+ *
+ * @example
+ * ```typescript
+ * renderIndexSignature(context, indexSignatureNode)
+ * // Returns: "[key: string]: any"
+ * // Returns: "readonly [key: number]: string"
+ * ```
+ */
+const renderIndexSignature = (context, indexSignature) => {
+    const readonly = indexSignature.isReadonly ? 'readonly ' : '';
+    const keyType = renderType(context, indexSignature.keyType);
+    const valueType = renderType(context, indexSignature.valueType);
+    return `${readonly}[key: ${keyType}]: ${valueType}`;
+};
+/**
+ * Renders an object type node as a string representation.
+ *
+ * Converts an ObjectNode into a TypeScript-like object type string, e.g.:
+ * `{ name: string, age: number }` or `{ [key: string]: any, name: string }`
+ *
+ * If the object has index signatures, they are rendered before regular properties.
+ *
+ * @param context - The rendering context containing the types reader
+ * @param objectTypeNode - The object type node to render
+ * @returns A string representation of the object type
+ *
+ * @example
+ * ```typescript
+ * renderObjectType(context, objectNode)
+ * // Returns: "{ name: string, age: number }"
+ * // Returns: "{ [key: string]: any }"
+ * // Returns: "{ readonly [key: number]: string, [name: string]: string, regularProperty: hello }"
+ * ```
+ */
+const renderObjectType = (context, objectTypeNode) => {
+    const { properties, indexSignatures } = objectTypeNode;
+    const hasIndexSignatures = indexSignatures && indexSignatures.length > 0;
+    const hasProperties = properties.length > 0;
+    // Empty object types render as just {}
+    if (!hasIndexSignatures && !hasProperties) {
+        return `{}`;
+    }
+    const parts = [];
+    // Render index signatures first
+    if (hasIndexSignatures) {
+        const indexParts = indexSignatures.map((indexSig) => renderIndexSignature(context, indexSig));
+        parts.push(...indexParts);
+    }
+    // Then render regular properties
+    if (hasProperties) {
+        const propertyParts = properties.map((property) => {
+            return `${property.name}: ${renderType(context, property.type)}`;
+        });
+        parts.push(...propertyParts);
+    }
+    return `{ ${parts.join(', ')} }`;
+};
+/**
+ * Renders an array type node as a string representation.
+ *
+ * Converts an ArrayNode into a TypeScript array type string, e.g.:
+ * `string[]` or `Array<string>`
+ *
+ * @param context - The rendering context containing the types reader
+ * @param arrayNode - The array type node to render
+ * @returns A string representation of the array type
+ *
+ * @example
+ * ```typescript
+ * renderArrayType(context, arrayNode)
+ * // Returns: "string[]" for simple types
+ * // Returns: "Array<"a" | "b">" for union types
+ * // Returns: "Array<A & B>" for intersection types
+ * // Returns: "Array<[string, number]>" for tuple types
+ * ```
+ */
+const renderArrayType = (context, arrayNode) => {
+    const elementType = arrayNode.elementType;
+    const targetElementType = getTargetTypeNode(context, elementType);
+    // Use Array<T> syntax for union/intersection/tuple types to avoid ambiguity with operator precedence
+    // e.g., Array<"red" | "green" | "blue"> instead of ("red" | "green" | "blue")[]
+    // e.g., Array<A & B> instead of A & B[]
+    // e.g., Array<[string, number]> instead of [string, number][]
+    if (isUnionNode(targetElementType) ||
+        isIntersectionNode(targetElementType) ||
+        isTupleNode(targetElementType)) {
+        return `Array<${renderType(context, elementType)}>`;
+    }
+    // Use T[] syntax for simple types
+    return `${renderType(context, elementType)}[]`;
+};
+/**
+ * Renders a tuple type node as a string representation.
+ *
+ * Converts a TupleNode into a TypeScript tuple type string, e.g.:
+ * `[string, number]` or `[string, number, ...boolean[]]`
+ *
+ * @param context - The rendering context containing the types reader
+ * @param tupleNode - The tuple type node to render
+ * @returns A string representation of the tuple type
+ *
+ * @example
+ * ```typescript
+ * renderTupleType(context, tupleNode)
+ * // Returns: "[string, number]"
+ * ```
+ */
+const renderTupleType = (context, tupleNode) => {
+    const elementParts = tupleNode.elements.map((element) => {
+        const renderedType = renderType(context, element.type);
+        // Handle rest elements (e.g., ...string[])
+        if (element.isRest) {
+            return `...${renderedType}`;
+        }
+        // Handle optional elements (e.g., string?)
+        if (element.isOptional) {
+            return `${renderedType}?`;
+        }
+        return renderedType;
+    });
+    return `[${elementParts.join(', ')}]`;
+};
+/**
+ * Renders a function type node as a string representation.
+ *
+ * Converts a FunctionNode into a TypeScript-like function type string, e.g.:
+ * `(param1: string, param2: number) => boolean`
+ *
+ * @param context - The rendering context containing the types reader
+ * @param functionNode - The function type node to render
+ * @returns A string representation of the function type
+ *
+ * @example
+ * ```typescript
+ * renderFunction(context, functionNode)
+ * // Returns: "(value: string) => boolean"
+ * ```
+ */
+const renderFunction = (context, functionNode) => {
+    const paramParts = [];
+    // Render each parameter as "name: type"
+    for (const param of functionNode.parameters) {
+        paramParts.push(`${param.name}: ${renderType(context, param.type)}`);
+    }
+    // Combine parameters and return type into function signature format
+    return `(${paramParts.join(', ')}) => ${renderType(context, functionNode.returnType)}`;
+};
+/**
+ * Main type rendering function that converts an API node to a string representation.
+ *
+ * This is a recursive function that handles all TypeScript type constructs:
+ * - Primitives (string, number, boolean, etc.)
+ * - Literal types (e.g., "hello" | "world")
+ * - External type references (types from other packages)
+ * - Function types
+ * - Object types
+ * - Inlined type references
+ * - Built-in generic types (Array<T>, Promise<T>, etc.)
+ * - Type references (aliases and interfaces)
+ * - Union types
+ *
+ * The function uses the context to track the current path of type nodes being rendered,
+ * which allows it to detect actual circular references (where a type references itself
+ * in its own definition) while still expanding types that appear multiple times in
+ * different parts of the type tree.
+ *
+ * @param context - The rendering context containing the types reader and current type path
+ * @param typeNode - The API node representing the type to render
+ * @returns A string representation of the type (e.g., "string", "Array<number>", "string | number")
+ */
+const renderType = (context, typeNode) => {
+    // Handle primitive types (string, number, boolean, etc.)
+    if (isPrimitiveNode(typeNode)) {
+        return typeNode.name;
+    }
+    // Handle literal types (e.g., "hello", 42, true)
+    if (isLiteralNode(typeNode)) {
+        return JSON.stringify(typeNode.value);
+    }
+    // Handle external type references (types from other packages/modules)
+    // These are rendered as-is since we don't have their definitions
+    if (isExternalTypeReferenceNode(typeNode)) {
+        return typeNode.typeString;
+    }
+    // Handle array types
+    if (isArrayNode(typeNode)) {
+        return renderArrayType(context, typeNode);
+    }
+    // Handle tuple types
+    if (isTupleNode(typeNode)) {
+        return renderTupleType(context, typeNode);
+    }
+    // Handle function types
+    if (isFunctionNode(typeNode)) {
+        return renderFunction(context, typeNode);
+    }
+    // Handle object types
+    if (isObjectNode(typeNode)) {
+        return renderObjectType(context, typeNode);
+    }
+    // Handle built-in generic types (Array<T>, Promise<T>, etc.)
+    if (isBuiltInTypeReferenceNode(typeNode)) {
+        const { name, typeArguments } = typeNode;
+        // Render type arguments if present (e.g., <string, number>)
+        const renderedTypeArguments = typeArguments
+            ? `<${typeArguments
+                .map((argType) => renderType(context, argType))
+                .join(', ')}>`
+            : '';
+        return `${name}${renderedTypeArguments}`;
+    }
+    // Handle type references (aliases, interfaces, etc.)
+    if (isTypeReferenceNode(typeNode)) {
+        // Look up the referenced type definition
+        const referencedNode = context.typesReader.findReferencedTypeById(typeNode.typeId);
+        // Check if this type node is already in the current path (actual recursion)
+        // If yes, return the type string instead of expanding to prevent infinite loop
+        if (context.typePath.includes(referencedNode)) {
+            return typeNode.typeString;
+        }
+        // Add to path before descending
+        context.typePath.push(referencedNode);
+        // Render the referenced type (may recurse through many paths)
+        const result = renderType(context, referencedNode);
+        // Remove from path after returning (ensures we pop even if renderType took complex paths)
+        context.typePath.pop();
+        return result;
+    }
+    // Handle union and intersection types (e.g., (string | number | boolean) and (A & B & C))
+    if (isUnionNode(typeNode) || isIntersectionNode(typeNode)) {
+        // Render each type in the union or intersection
+        const renderedParts = typeNode.types.map((type) => renderType(context, type));
+        // Sort parts alphabetically for consistent output
+        renderedParts.sort((a, b) => a.localeCompare(b));
+        const separator = isUnionNode(typeNode) ? '|' : '&';
+        return renderedParts.join(` ${separator} `);
+    }
+    throw new Error(`Unsupported type node: ${typeNode.kind}`);
+};
+/**
+ * Checks if a value is a non-empty array.
+ *
+ * @param array - The value to check
+ * @returns True if the value is an array with at least one element
+ */
+const isNonEmptyArray = (array) => Array.isArray(array) && array.length > 0;
+/**
+ * Checks if a type node has type arguments (generic parameters).
+ *
+ * @param typeNode - The type node to check (must be InlinedTypeReferenceNode or TypeReferenceNode)
+ * @returns True if the type node has type arguments
+ */
+const hasTypeArgs = (typeNode) => isNonEmptyArray(typeNode.typeArguments);
+/**
+ * Resolves a type node to its target type, handling type references and inlined references.
+ *
+ * For prop type rendering, we want to resolve type references to their actual definitions,
+ * but we want to preserve generic type arguments. This function:
+ * - For inlined type references: returns the node itself if it has type args, otherwise resolves to inner type
+ * - For type references: returns the node itself if it has type args, otherwise resolves to referenced type
+ * - For other nodes: returns the node as-is
+ *
+ * This ensures that generic types like `Array<string>` are preserved, while simple
+ * type aliases are resolved to their underlying types.
+ *
+ * @param context - The rendering context containing the types reader
+ * @param typeNode - The type node to resolve
+ * @returns The resolved target type node
+ */
+const getTargetTypeNode = (context, typeNode) => {
+    // For type references, preserve the node if it has type args (generics)
+    // Otherwise, look up and return the referenced type definition
+    if (isTypeReferenceNode(typeNode)) {
+        return hasTypeArgs(typeNode)
+            ? typeNode
+            : context.typesReader.findReferencedTypeById(typeNode.typeId);
+    }
+    // For other node types, return as-is
+    return typeNode;
+};
+const renderPropTypeToJsxHelper = (context, propType) => {
+    // Resolve references to other types to the actual type node
+    // This handles type aliases and ensures generics are preserved
+    const targetPropType = getTargetTypeNode(context, propType);
+    // Special handling for union types: render each member recursively and sort
+    // This ensures nested unions are properly formatted
+    if (isUnionNode(targetPropType)) {
+        const renderedUnionTypes = targetPropType.types.map((currentType) => renderPropTypeToJsxHelper(context, currentType));
+        // Sort union parts alphabetically for consistent output
+        renderedUnionTypes.sort((a, b) => a.localeCompare(b));
+        return renderedUnionTypes.join(' | ');
+    }
+    return wrapCodeInHtmlCodeTags(renderType(context, targetPropType));
+};
+/**
+ * Renders a prop's type as an HTML string.
+ *
+ * This function handles the special case of union types in props, which need
+ * to be rendered recursively. All types are wrapped in HTML code tags for
+ * proper HTML rendering.
+ *
+ * @param context - The rendering context containing the types reader
+ * @param propType - The API node representing the prop's type
+ * @returns An HTML string representation of the type (wrapped in code tags)
+ *
+ * @example
+ * ```typescript
+ * renderPropTypeToHtml(context, stringNode) // Returns: "<code>string</code>"
+ * renderPropTypeToHtml(context, unionNode) // Returns: "<code>boolean</code> | <code>number</code> | <code>string</code>"
+ * ```
+ */
+export const renderPropTypeToJsx = (context, propType) => {
+    return `<>${renderPropTypeToJsxHelper(context, propType)}</>`;
+};

package/dist/internal/utils/jsdoc-utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * JSDoc utilities for extracting metadata from JSDoc tags.
+ *
+ * This module provides helper functions for parsing and extracting information
+ * from JSDoc comments associated with component props, such as default values.
+ */
+import { JsdocTag } from '@hubspot/ts-export-types-reader';
+/**
+ * Extracts the default value from JSDoc tags.
+ *
+ * Searches through an array of JSDoc tags to find a tag named 'defaultValue'
+ * and returns its text content. This is used to display default values in
+ * the component props documentation tables.
+ *
+ * @param tags - An array of JSDoc tags, or undefined if no tags exist
+ * @returns The default value text if found, or null if not found or if tags is undefined
+ */
+export declare const getDefaultValueFromJsdocTags: (tags: JsdocTag[] | undefined) => string | null;
+/**
+ * Extracts see tags from JSDoc tags.
+ *
+ * Searches through an array of JSDoc tags to find tags named 'see'
+ * and returns their text content. See tags are used to reference related
+ * documentation or external resources.
+ *
+ * @param tags - An array of JSDoc tags, or undefined if no tags exist
+ * @returns An array of see tag text values, or an empty array if none found
+ */
+export declare const getSeeTagsFromJsdocTags: (tags: JsdocTag[] | undefined) => string[];

package/dist/internal/utils/jsdoc-utils.js

@@ -0,0 +1,52 @@
+/**
+ * JSDoc utilities for extracting metadata from JSDoc tags.
+ *
+ * This module provides helper functions for parsing and extracting information
+ * from JSDoc comments associated with component props, such as default values.
+ */
+/**
+ * Extracts the default value from JSDoc tags.
+ *
+ * Searches through an array of JSDoc tags to find a tag named 'defaultValue'
+ * and returns its text content. This is used to display default values in
+ * the component props documentation tables.
+ *
+ * @param tags - An array of JSDoc tags, or undefined if no tags exist
+ * @returns The default value text if found, or null if not found or if tags is undefined
+ */
+export const getDefaultValueFromJsdocTags = (tags) => {
+    // Return null if there are no tags
+    if (!tags) {
+        return null;
+    }
+    // Search through tags to find the defaultValue tag
+    for (const tag of tags) {
+        if (tag.name === 'defaultValue') {
+            // Return the tag's text, or null if text is empty/undefined
+            return tag.text || null;
+        }
+    }
+    // No defaultValue tag found
+    return null;
+};
+/**
+ * Extracts see tags from JSDoc tags.
+ *
+ * Searches through an array of JSDoc tags to find tags named 'see'
+ * and returns their text content. See tags are used to reference related
+ * documentation or external resources.
+ *
+ * @param tags - An array of JSDoc tags, or undefined if no tags exist
+ * @returns An array of see tag text values, or an empty array if none found
+ */
+export const getSeeTagsFromJsdocTags = (tags) => {
+    // Return empty array if there are no tags
+    if (!tags) {
+        return [];
+    }
+    // Search through tags to find the @see tags and extract their text
+    // Filter out any tags with empty or undefined text
+    return tags
+        .filter((tag) => tag.name === 'see' && tag.text)
+        .map((tag) => tag.text);
+};

package/dist/internal/utils/jsx-utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Wraps code as text in HTML code tags for HTML rendering. Special HTML characters are escaped.
+ *
+ * @param value - The code as text to wrap in HTML code tags
+ * @returns The code as text wrapped in HTML code tags
+ */
+export declare const wrapCodeInHtmlCodeTags: (value: string) => string;
+/**
+ * Converts HTML to XHTML (well-formed XML) by ensuring all void elements
+ * are self-closing and the output is valid XML.
+ *
+ * This is necessary because the generated HTML will be embedded in JSX
+ * fragments, which require valid XML syntax. For example, `<br>` must
+ * become `<br/>` and `<img src="...">` must become `<img src="..."/>`.
+ *
+ * Outermost `<p>` tags are stripped when the content is a single paragraph to allow
+ * for cleaner inline rendering. When multiple block elements exist (e.g., text followed
+ * by a list), the structure is preserved.
+ *
+ * @param html - The HTML string to convert
+ * @returns The HTML converted to XHTML format with self-closing tags
+ *
+ * @example
+ * ```typescript
+ * convertHtmlToJsx('<p>Hello<br>World</p>')
+ * // Returns: 'Hello<br/>World'
+ *
+ * convertHtmlToJsx('<img src="test.png">')
+ * // Returns: '<img src="test.png"/>'
+ * ```
+ */
+export declare const convertHtmlToJsx: (html: string) => string;

package/dist/internal/utils/jsx-utils.js

@@ -0,0 +1,77 @@
+import { parseDocument, DomUtils } from 'htmlparser2';
+import serialize from 'dom-serializer';
+const escapeJsxExpressions = (jsx) => {
+    return jsx.replaceAll('{', '{').replaceAll('}', '}');
+};
+const sanitizeHtmlTextForCodeBlock = (htmlText) => {
+    return escapeJsxExpressions(htmlText
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;'));
+    // NOTE: We are not putting HTML inside an HTML attribute so we don't need to escape quotes or apostrophes
+};
+/**
+ * Wraps code as text in HTML code tags for HTML rendering. Special HTML characters are escaped.
+ *
+ * @param value - The code as text to wrap in HTML code tags
+ * @returns The code as text wrapped in HTML code tags
+ */
+export const wrapCodeInHtmlCodeTags = (value) => {
+    return `<code>${sanitizeHtmlTextForCodeBlock(value)}</code>`;
+};
+const stripOutermostParagraphNode = (dom) => {
+    // Check if there's exactly one root element and it's a <p> tag
+    const rootChildren = dom.children;
+    if (rootChildren.length !== 1) {
+        return;
+    }
+    const firstChild = rootChildren[0];
+    if (firstChild.type !== 'tag' || firstChild.name !== 'p') {
+        return;
+    }
+    // Move all of the children of the <p> element node to the root DOM node
+    const childrenToMove = [...firstChild.childNodes];
+    for (const child of childrenToMove) {
+        DomUtils.appendChild(dom, child);
+    }
+    // Now remove the <p> element node
+    DomUtils.removeElement(firstChild);
+};
+/**
+ * Converts HTML to XHTML (well-formed XML) by ensuring all void elements
+ * are self-closing and the output is valid XML.
+ *
+ * This is necessary because the generated HTML will be embedded in JSX
+ * fragments, which require valid XML syntax. For example, `<br>` must
+ * become `<br/>` and `<img src="...">` must become `<img src="..."/>`.
+ *
+ * Outermost `<p>` tags are stripped when the content is a single paragraph to allow
+ * for cleaner inline rendering. When multiple block elements exist (e.g., text followed
+ * by a list), the structure is preserved.
+ *
+ * @param html - The HTML string to convert
+ * @returns The HTML converted to XHTML format with self-closing tags
+ *
+ * @example
+ * ```typescript
+ * convertHtmlToJsx('<p>Hello<br>World</p>')
+ * // Returns: 'Hello<br/>World'
+ *
+ * convertHtmlToJsx('<img src="test.png">')
+ * // Returns: '<img src="test.png"/>'
+ * ```
+ */
+export const convertHtmlToJsx = (html) => {
+    // Parse HTML into a DOM structure (parse as HTML to handle loose syntax)
+    const dom = parseDocument(html, {
+        xmlMode: false,
+    });
+    // Remove unnecessary outermost <p> tag
+    stripOutermostParagraphNode(dom);
+    // Serialize back to string with XML rules (self-closing tags, etc.)
+    const xhtml = serialize(dom, {
+        xmlMode: true, // Use XML/XHTML serialization rules
+        selfClosingTags: true, // Ensure void elements are self-closing
+    });
+    return `<>${escapeJsxExpressions(xhtml)}</>`;
+};

package/dist/internal/utils/markdown-utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Renders markdown text to JSX.
+ *
+ * Supports both inline elements (emphasis, code spans, links) and block-level
+ * elements (lists, paragraphs, headings). The output is converted to XHTML format
+ * to ensure it's valid XML/JSX, with all void elements properly self-closing
+ * (e.g., `<br/>` instead of `<br>`).
+ *
+ * @param markdownText - The markdown text to render to HTML
+ * @returns The markdown text rendered to XHTML
+ */
+export declare const renderMarkdownToJsx: (markdownText: string) => string;

package/dist/internal/utils/markdown-utils.js

@@ -0,0 +1,21 @@
+import { Marked } from 'marked';
+import { convertHtmlToJsx } from "./jsx-utils.js";
+const markedInstance = new Marked({
+    breaks: true,
+    gfm: true,
+});
+/**
+ * Renders markdown text to JSX.
+ *
+ * Supports both inline elements (emphasis, code spans, links) and block-level
+ * elements (lists, paragraphs, headings). The output is converted to XHTML format
+ * to ensure it's valid XML/JSX, with all void elements properly self-closing
+ * (e.g., `<br/>` instead of `<br>`).
+ *
+ * @param markdownText - The markdown text to render to HTML
+ * @returns The markdown text rendered to XHTML
+ */
+export const renderMarkdownToJsx = (markdownText) => {
+    const html = markedInstance.parse(markdownText).toString().trim();
+    return convertHtmlToJsx(html);
+};

package/dist/types.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Documentation for a component prop.
+ */
+export interface ComponentPropDocumentation {
+    /**
+     * The name of the prop.
+     */
+    name: string;
+    /**
+     * Whether the prop is required.
+     */
+    required: boolean;
+    /**
+     * The type of the prop as a JSX code string (e.g., `"<><code>boolean</code></>"`).
+     */
+    typeJsx: string;
+    /**
+     * The default value of the prop as a JSX code string (e.g., `"<><code>false</code></>"`).
+     */
+    defaultValueJsx?: string;
+    /**
+     * The description of the prop as a JSX code string (e.g., `"<>The description of the prop.</>"`).
+     */
+    descriptionJsx: string;
+    /**
+     * The see items of the prop as JSX code strings (e.g., `["<><a href="https://example.com">Example</a></>"]`).
+     *
+     * These are typically markup for links to other documentation related to the prop.
+     */
+    seeJsxItems?: string[];
+}
+/**
+ * The names of the components in the `@hubspot/ui-extensions` package.
+ *
+ * FUTURE: We should use code generation to generate this enum.
+ */
+export declare enum ComponentName {
+    Accordion = "Accordion",
+    Alert = "Alert",
+    AutoGrid = "AutoGrid",
+    BarChart = "BarChart",
+    Box = "Box",
+    Button = "Button",
+    ButtonRow = "ButtonRow",
+    Card = "Card",
+    Center = "Center",
+    Checkbox = "Checkbox",
+    CrmActionButton = "CrmActionButton",
+    CrmActionLink = "CrmActionLink",
+    CrmAssociationPivot = "CrmAssociationPivot",
+    CrmAssociationPropertyList = "CrmAssociationPropertyList",
+    CrmAssociationStageTracker = "CrmAssociationStageTracker",
+    CrmAssociationTable = "CrmAssociationTable",
+    CrmCardActions = "CrmCardActions",
+    CrmDataHighlight = "CrmDataHighlight",
+    CrmPropertyList = "CrmPropertyList",
+    CrmReport = "CrmReport",
+    CrmSimpleDeadline = "CrmSimpleDeadline",
+    CrmStageTracker = "CrmStageTracker",
+    CrmStatistics = "CrmStatistics",
+    CurrencyInput = "CurrencyInput",
+    DateInput = "DateInput",
+    DescriptionList = "DescriptionList",
+    DescriptionListItem = "DescriptionListItem",
+    Divider = "Divider",
+    Dropdown = "Dropdown",
+    DropdownButtonItem = "DropdownButtonItem",
+    EmptyState = "EmptyState",
+    ErrorState = "ErrorState",
+    ExpandableText = "ExpandableText",
+    FileInput = "FileInput",
+    Flex = "Flex",
+    Form = "Form",
+    Grid = "Grid",
+    GridItem = "GridItem",
+    HeaderActions = "HeaderActions",
+    Heading = "Heading",
+    Icon = "Icon",
+    Iframe = "Iframe",
+    Illustration = "Illustration",
+    Image = "Image",
+    Inline = "Inline",
+    Input = "Input",
+    LineChart = "LineChart",
+    Link = "Link",
+    List = "List",
+    LoadingButton = "LoadingButton",
+    LoadingSpinner = "LoadingSpinner",
+    MediaObject = "MediaObject",
+    Modal = "Modal",
+    ModalBody = "ModalBody",
+    ModalFooter = "ModalFooter",
+    MultiSelect = "MultiSelect",
+    NumberInput = "NumberInput",
+    Panel = "Panel",
+    PanelBody = "PanelBody",
+    PanelFooter = "PanelFooter",
+    PanelSection = "PanelSection",
+    Popover = "Popover",
+    PrimaryHeaderActionButton = "PrimaryHeaderActionButton",
+    ProgressBar = "ProgressBar",
+    RadioButton = "RadioButton",
+    ScoreCircle = "ScoreCircle",
+    SearchInput = "SearchInput",
+    SecondaryHeaderActionButton = "SecondaryHeaderActionButton",
+    Select = "Select",
+    SettingsView = "SettingsView",
+    Stack2 = "Stack2",
+    Statistics = "Statistics",
+    StatisticsItem = "StatisticsItem",
+    StatisticsTrend = "StatisticsTrend",
+    StatusTag = "StatusTag",
+    StepIndicator = "StepIndicator",
+    StepperInput = "StepperInput",
+    Tab = "Tab",
+    Table = "Table",
+    TableBody = "TableBody",
+    TableCell = "TableCell",
+    TableFooter = "TableFooter",
+    TableHead = "TableHead",
+    TableHeader = "TableHeader",
+    TableRow = "TableRow",
+    Tabs = "Tabs",
+    Tag = "Tag",
+    Text = "Text",
+    TextArea = "TextArea",
+    Tile = "Tile",
+    TimeInput = "TimeInput",
+    Toggle = "Toggle",
+    ToggleGroup = "ToggleGroup",
+    Tooltip = "Tooltip"
+}