@gov-design-system-ce/components 4.6.5-b → 4.6.5

package/dist/dist/dist/types/types/event.types.d.ts

@@ -0,0 +1,4 @@
+export interface GovBaseEvent {
+    component: string;
+    originalEvent?: Event;
+}

package/dist/dist/dist/types/types/interfaces.d.ts

@@ -0,0 +1,2 @@
+export type Nullable<T> = T | null;
+export type ValueOf<T> = T[keyof T];

package/dist/dist/dist/types/types/typings.d.ts

@@ -0,0 +1,6 @@
+declare module '*.jpg'
+
+declare module '*.md' {
+	const value: string // markdown is just a string
+	export default value
+}

package/dist/dist/dist/types/utils/array.utils.d.ts

@@ -0,0 +1,2 @@
+export declare const createArrayRange: (from: number, to: number) => number[];
+export declare const propsValueToArray: <T>(value: unknown) => T;

package/dist/dist/dist/types/utils/bool.utils.d.ts

@@ -0,0 +1 @@
+export declare function toBool(value: any): boolean;

package/dist/dist/dist/types/utils/dom.utils.d.ts

@@ -0,0 +1 @@
+export declare function getFocusableElements(container: HTMLElement): Element[];

package/dist/dist/dist/types/utils/ds.utils.d.ts

@@ -0,0 +1 @@
+export declare const dsVersion: () => string;

package/dist/dist/dist/types/utils/file.utils.d.ts

@@ -0,0 +1,3 @@
+export declare function formatBytes(bytes: any): string;
+export declare function fileAcceptValidation(file: File, accept: string): boolean;
+export declare function fileSizeValidation(file: File, maxSize: number): boolean;

package/dist/dist/dist/types/utils/helpers.types.d.ts

@@ -0,0 +1,49 @@
+export type Optional<T> = T | undefined;
+export type Nullable<T> = T | null;
+export type OptionalProperty<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export type ValueOf<T> = T[keyof T];
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type ObjectOrArrayType<T> = T | T[];
+export declare const ObjectOrArray: {
+    first: <T>(item: ObjectOrArrayType<T>) => T;
+    array: <T>(item: ObjectOrArrayType<T>) => T[];
+};
+export declare const Omit: <T extends object, P extends keyof T, R extends Omit<T, P>>(properties: P[], object: T) => R;
+export declare const whenDefined: <I, O>(fn: (input: I) => O) => (value?: I) => O | undefined;
+/**
+ * Comparator function which defines the sort order
+ * @example
+ * ```
+ * // sorts objects by `id` property
+ * [{ id: 3 }, { id: 2 }, { id: 1 }].sort(compare(['id']))
+ *
+ * // sorts objects by `id` and `name` properties
+ * [{ id: 3, name: 'b' }, { id: 2, name: 'a' }, { id: 1, name: 'b' }].sort(compare(['id', 'name']))
+ * ```
+ *
+ * @param {Array<keyof T>} properties
+ * @return {number}
+ */
+export declare const compare: <T extends object>(properties: Array<keyof T>) => (a: T, b: T) => number;
+export declare const is: <T>(value: T | undefined | null) => value is T;
+export declare const has: <T extends object, P extends keyof T>(property: P) => (object: OptionalProperty<T, P>) => object is T;
+export declare const equals: <A>(a?: A) => (b?: A) => boolean;
+export declare const prop: <T, P extends keyof T>(property: P) => (object: T) => T[P];
+export declare const propOptional: <T, P extends keyof T>(property: P) => (object?: T) => Optional<T[P]>;
+export declare const hasOwnProperty: <X extends object, Y extends PropertyKey>(obj: X, prop: Y) => obj is X & Record<Y, ValueOf<X>>;
+export declare const isObject: <T extends object>(obj: unknown) => obj is T;
+export declare const isString: (input: unknown) => input is string;
+export declare const isNumber: (input: unknown) => input is string;
+type Entries<T> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
+export declare const getEntries: <T extends object>(obj: T) => Entries<T>;
+export declare const getKeys: <T extends object>(obj: T) => Array<keyof T>;
+export declare const getValues: <T extends object>(obj: T) => Array<ValueOf<T>>;
+export declare const first: <T>(array: T[]) => Optional<T>;
+export declare const pairs: <T>(arr: T[]) => Array<[string, string]>;
+export declare const find: <T, S extends T>(predicate: (item: T) => item is S) => (array?: T[]) => Optional<S>;
+export declare const filter: <T, S extends T>(predicate: (item: T) => item is S) => (array?: T[]) => S[];
+export {};

package/dist/dist/dist/types/utils/icon.utils.d.ts

@@ -0,0 +1,4 @@
+export declare function fetchIcon({ name, type }: {
+    name: string;
+    type: string;
+}): Promise<string>;

package/dist/dist/dist/types/utils/number.utils.d.ts

@@ -0,0 +1 @@
+export declare const randomNumber: (min: number, max: number) => number;

package/dist/dist/dist/types/utils/object.utils.d.ts

@@ -0,0 +1,2 @@
+export declare const parseJSONString: (value: unknown) => object | [] | null;
+export declare const propsValueToObject: <T>(value: unknown) => T;

package/dist/dist/dist/types/utils/stencil.utils.d.ts

@@ -0,0 +1 @@
+export declare const tick: (callback: () => void) => void;

package/dist/dist/dist/types/utils/string.utils.d.ts

@@ -0,0 +1,4 @@
+export declare function chr4(): string;
+export declare function createID(prefix: string): string;
+export declare function removeDiacritics(string: any): string | any;
+export declare function splitByWhitespace(string: any): string | any;

package/dist/dist/dist/types/utils/utils.d.ts

@@ -0,0 +1,20 @@
+export declare function format(first: string, middle: string, last: string): string;
+export declare function delay(miliseconds: number): Promise<void>;
+export declare function throttle(f: (entries: any) => void, delay: number): (...args: any[]) => void;
+/**
+ * Checks if object has that property
+ *
+ * @param {K} prop
+ * @param {T} obj
+ * @return {obj is T & Record<K, V>}
+ */
+export declare const has: <T extends object, K extends PropertyKey, V>(prop: K, obj: T) => obj is T & Record<K, V>;
+/**
+ * Returns property of given Object
+ *
+ * @param {K} name
+ * @param {T} object
+ * @return {(T & Record<K, unknown>)[K]}
+ */
+export declare const property: <T extends object, K extends keyof T>(name: K, object: T) => T[K];
+export declare const pick: <T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: readonly K[]) => Pick<T, K>;

package/dist/dist/globals.d.ts

@@ -0,0 +1,2 @@
+declare module "*.md";
+declare module "*.json";

package/dist/dist/hydrate/index.d.ts

@@ -0,0 +1,287 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import { Readable } from 'node:stream';
+
+export declare function createWindowFromHtml(templateHtml: string, uniqueId: string): any;
+export type TagTransformer = (tag: string) => string;
+/**
+ * Serialize a value to a string that can be deserialized later.
+ * @param {unknown} value - The value to serialize.
+ * @returns {string} A string that can be deserialized later.
+ * @deprecated will be removed in v5. Use `@PropSerialize()` decorator instead.
+ */
+export declare function serializeProperty(value: unknown): string | number | boolean;
+/**
+ * Deserialize a value from a string that was serialized earlier.
+ * @param {string} value - The string to deserialize.
+ * @returns {unknown} The deserialized value.
+ * @deprecated will be removed in v5. Use `@AttrDeserialize()` decorator instead.
+ */
+export declare function deserializeProperty(value: string): any;
+export type ResolutionHandler = (elm: HTMLElement) => string | undefined | null;
+export interface HydrateDocumentOptions {
+	/**
+	 * Build ID that will be added to `<html data-stencil-build="BUILD_ID">`. By default
+	 * a random ID will be generated
+	 */
+	buildId?: string;
+	/**
+	 * Sets the `href` attribute on the `<link rel="canonical">`
+	 * tag within the `<head>`. If the value is not defined it will
+	 * ensure a canonical link tag is no included in the `<head>`.
+	 */
+	canonicalUrl?: string;
+	/**
+	 * Include the HTML comments and attributes used by the client-side
+	 * JavaScript to read the structure of the HTML and rebuild each
+	 * component. Defaults to `true`.
+	 */
+	clientHydrateAnnotations?: boolean;
+	/**
+	 * Constrain `setTimeout()` to 1ms, but still async. Also
+	 * only allows `setInterval()` to fire once, also constrained to 1ms.
+	 * Defaults to `true`.
+	 */
+	constrainTimeouts?: boolean;
+	/**
+	 * Sets `document.cookie`
+	 */
+	cookie?: string;
+	/**
+	 * Sets the `dir` attribute on the top level `<html>`.
+	 */
+	direction?: string;
+	/**
+	 * Component tag names listed here will not be prerendered, nor will
+	 * hydrated on the client-side. Components listed here will be ignored
+	 * as custom elements and treated no differently than a `<div>`.
+	 */
+	excludeComponents?: string[];
+	/**
+	 * Sets the `lang` attribute on the top level `<html>`.
+	 */
+	language?: string;
+	/**
+	 * Maximum number of components to hydrate on one page. Defaults to `300`.
+	 */
+	maxHydrateCount?: number;
+	/**
+	 * Sets `document.referrer`
+	 */
+	referrer?: string;
+	/**
+	 * Removes every `<script>` element found in the `document`. Defaults to `false`.
+	 */
+	removeScripts?: boolean;
+	/**
+	 * Removes CSS not used by elements within the `document`. Defaults to `true`.
+	 */
+	removeUnusedStyles?: boolean;
+	/**
+	 * The url the runtime uses for the resources, such as the assets directory.
+	 */
+	resourcesUrl?: string;
+	/**
+	 * Prints out runtime console logs to the NodeJS process. Defaults to `false`.
+	 */
+	runtimeLogging?: boolean;
+	/**
+	 * Component tags listed here will only be prerendered or server-side-rendered
+	 * and will not be client-side hydrated. This is useful for components that
+	 * are not dynamic and do not need to be defined as a custom element within the
+	 * browser. For example, a header or footer component would be a good example that
+	 * may not require any client-side JavaScript.
+	 */
+	staticComponents?: string[];
+	/**
+	 * The amount of milliseconds to wait for a page to finish rendering until
+	 * a timeout error is thrown. Defaults to `15000`.
+	 */
+	timeout?: number;
+	/**
+	 * Sets `document.title`.
+	 */
+	title?: string;
+	/**
+	 * Sets `location.href`
+	 */
+	url?: string;
+	/**
+	 * Sets `navigator.userAgent`
+	 */
+	userAgent?: string;
+	/**
+	 * Configure how Stencil serializes the components shadow root.
+	 * - If set to `declarative-shadow-dom` the component will be rendered within a Declarative Shadow DOM.
+	 * - If set to `scoped` Stencil will render the contents of the shadow root as a `scoped: true` component
+	 *   and the shadow DOM will be created during client-side hydration.
+	 * - Alternatively you can mix and match the two by providing an object with `declarative-shadow-dom` and `scoped` keys,
+	 * the value arrays containing the tag names of the components that should be rendered in that mode.
+	 *
+	 * Examples:
+	 * - `{ 'declarative-shadow-dom': ['my-component-1', 'another-component'], default: 'scoped' }`
+	 * Render all components as `scoped` apart from `my-component-1` and `another-component`
+	 * -  `{ 'scoped': ['an-option-component'], default: 'declarative-shadow-dom' }`
+	 * Render all components within `declarative-shadow-dom` apart from `an-option-component`
+	 * - `'scoped'` Render all components as `scoped`
+	 * - `false` disables shadow root serialization
+	 *
+	 * *NOTE* `true` has been deprecated in favor of `declarative-shadow-dom` and `scoped`
+	 * @default 'declarative-shadow-dom'
+	 */
+	serializeShadowRoot?: "declarative-shadow-dom" | "scoped" | {
+		"declarative-shadow-dom"?: string[];
+		scoped?: string[];
+		default: "declarative-shadow-dom" | "scoped";
+	} | boolean;
+}
+export interface SerializeDocumentOptions extends HydrateDocumentOptions {
+	/**
+	 * Runs after the `document` has been hydrated.
+	 */
+	afterHydrate?(document: any): any | Promise<any>;
+	/**
+	 * Sets an approximate line width the HTML should attempt to stay within.
+	 * Note that this is "approximate", in that HTML may often not be able
+	 * to be split at an exact line width. Additionally, new lines created
+	 * is where HTML naturally already has whitespace, such as before an
+	 * attribute or spaces between words. Defaults to `100`.
+	 */
+	approximateLineWidth?: number;
+	/**
+	 * Runs before the `document` has been hydrated.
+	 */
+	beforeHydrate?(document: any): any | Promise<any>;
+	/**
+	 * Format the HTML in a nicely indented format.
+	 * Defaults to `false`.
+	 */
+	prettyHtml?: boolean;
+	/**
+	 * Remove quotes from attribute values when possible.
+	 * Defaults to `true`.
+	 */
+	removeAttributeQuotes?: boolean;
+	/**
+	 * Remove the `=""` from standardized `boolean` attributes,
+	 * such as `hidden` or `checked`. Defaults to `true`.
+	 */
+	removeBooleanAttributeQuotes?: boolean;
+	/**
+	 * Remove these standardized attributes when their value is empty:
+	 * `class`, `dir`, `id`, `lang`, and `name`, `title`. Defaults to `true`.
+	 */
+	removeEmptyAttributes?: boolean;
+	/**
+	 * Remove HTML comments. Defaults to `true`.
+	 */
+	removeHtmlComments?: boolean;
+	/**
+	 * The `fullDocument` flag determines the format of the rendered output. Set it to true to
+	 * generate a complete HTML document, or false to render only the component.
+	 * @default true
+	 */
+	fullDocument?: boolean;
+	/**
+	 * Style modes to render the component in.
+	 * @see https://stenciljs.com/docs/styling#style-modes
+	 */
+	modes?: ResolutionHandler[];
+}
+export interface HydrateFactoryOptions extends SerializeDocumentOptions {
+	serializeToHtml: boolean;
+	destroyWindow: boolean;
+	destroyDocument: boolean;
+}
+export interface Diagnostic {
+	absFilePath?: string | undefined;
+	code?: string;
+	columnNumber?: number | undefined;
+	debugText?: string;
+	header?: string;
+	language?: string;
+	level: "error" | "warn" | "info" | "log" | "debug";
+	lineNumber?: number | undefined;
+	lines: PrintLine[];
+	messageText: string;
+	relFilePath?: string | undefined;
+	type: string;
+}
+export interface PrintLine {
+	lineIndex: number;
+	lineNumber: number;
+	text: string;
+	errorCharStart: number;
+	errorLength?: number;
+}
+export interface HydrateResults {
+	buildId: string;
+	diagnostics: Diagnostic[];
+	url: string;
+	host: string | null;
+	hostname: string | null;
+	href: string | null;
+	port: string | null;
+	pathname: string | null;
+	search: string | null;
+	hash: string | null;
+	html: string | null;
+	components: HydrateComponent[];
+	anchors: HydrateAnchorElement[];
+	imgs: HydrateImgElement[];
+	scripts: HydrateScriptElement[];
+	styles: HydrateStyleElement[];
+	staticData: HydrateStaticData[];
+	title: string | null;
+	hydratedCount: number;
+	httpStatus: number | null;
+}
+export interface HydrateComponent {
+	tag: string;
+	mode: string;
+	count: number;
+	depth: number;
+}
+export interface HydrateElement {
+	[attrName: string]: string | undefined;
+}
+export interface HydrateAnchorElement extends HydrateElement {
+	href?: string;
+	target?: string;
+}
+export interface HydrateImgElement extends HydrateElement {
+	src?: string;
+}
+export interface HydrateScriptElement extends HydrateElement {
+	src?: string;
+	type?: string;
+}
+export interface HydrateStyleElement extends HydrateElement {
+	id?: string;
+	href?: string;
+	content?: string;
+}
+export interface HydrateStaticData {
+	id: string;
+	type: string;
+	content: string;
+}
+export declare function streamToString(html: string | any, option?: SerializeDocumentOptions): Readable;
+export declare function renderToString(html: string | any, options?: SerializeDocumentOptions): Promise<HydrateResults>;
+export declare function renderToString(html: string | any, options: SerializeDocumentOptions | undefined, asStream: true): Readable;
+export declare function hydrateDocument(doc: any | string, options?: HydrateDocumentOptions): Promise<HydrateResults>;
+export declare function hydrateDocument(doc: any | string, options: HydrateDocumentOptions | undefined, asStream?: boolean): Readable;
+export declare function serializeDocumentToString(doc: Document, opts: HydrateFactoryOptions): string;
+/**
+ * Transforms a tag name using the current tag transformer
+ * @param tag - the tag to transform e.g. `my-tag`
+ * @returns the transformed tag e.g. `new-my-tag`
+ */
+export declare function transformTag<T extends string>(tag: T): T;
+/**
+ * Sets the tag transformer to be used when rendering custom elements
+ * @param transformer the transformer function to use. Must return a string
+ */
+export declare function setTagTransformer(transformer: TagTransformer): void;
+
+export {};

package/dist/dist/types/components/gov-accordion/constants.d.ts

@@ -0,0 +1,19 @@
+import { Sizes } from '../../core/constants/sizes';
+import { ValueOf } from '../../types/interfaces';
+export declare const AccordionSizes: Pick<typeof Sizes, "_XS" | "_S" | "_M" | "_L" | "_XL">;
+export type AccordionSizeType = `${ValueOf<typeof AccordionSizes>}`;
+export declare const AccordionClass: {
+    root: string;
+};
+export declare const AccordionItemClass: {
+    root: string;
+    disabled: string;
+    details: string;
+    summary: string;
+    icon: string;
+    title: string;
+    suffix: string;
+    right: string;
+    arrow: string;
+    content: string;
+};

package/dist/dist/types/components/gov-accordion/gov-accordion-item.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+import { AccordionSizeType } from "./constants";
+import { AccordionItemEvent } from "./gov-accordion.types";
+export declare class GovAccordionItem {
+    private h;
+    private inheritedAttributes;
+    constructor();
+    readonly host: HTMLGovAccordionItemElement;
+    openState: boolean;
+    /**
+     * Custom accordion item identifier.
+     */
+    readonly identifier: string;
+    /**
+     * Accordion’s size.
+     */
+    size?: AccordionSizeType;
+    /**
+     * Makes the button component disabled.
+     */
+    readonly disabled: boolean;
+    /**
+     * Defines whether the accordion is open or closed by button
+     */
+    open: boolean;
+    /**
+     * Called when the accordion state changes
+     */
+    govChange: EventEmitter<AccordionItemEvent>;
+    validateSize(newValue: string): void;
+    componentWillLoad(): void;
+    componentDidRender(): void;
+    private getPropsFromParents;
+    render(): any;
+    /**
+     * Accordion switch
+     */
+    toggle(): Promise<void>;
+    /**
+     * Returns the current state of the component
+     */
+    currentState(): Promise<boolean>;
+}

package/dist/dist/types/components/gov-accordion/gov-accordion.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { AccordionSizeType } from './constants';
+import { AccordionEvent } from "./gov-accordion.types";
+export declare class GovAccordion {
+    private h;
+    private hydrated;
+    constructor();
+    readonly host: HTMLGovAccordionElement;
+    /**
+     * Accordion’s size.
+     */
+    readonly size?: AccordionSizeType;
+    /**
+     * Accordion item underline
+     */
+    readonly noBorder: boolean;
+    /**
+     * Called when the accordion state changes
+     */
+    govChange: EventEmitter<AccordionEvent>;
+    validateSize(newValue: string): void;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    connectedCallback(): void;
+    render(): any;
+}

package/dist/dist/types/components/gov-accordion/gov-accordion.types.d.ts

@@ -0,0 +1,9 @@
+import { GovBaseEvent } from "../../types/event.types";
+export interface AccordionItemEvent extends GovBaseEvent {
+    open: boolean;
+    ref: HTMLGovAccordionItemElement;
+}
+export interface AccordionEvent extends GovBaseEvent {
+    open: boolean;
+    ref: HTMLGovAccordionItemElement;
+}

package/dist/dist/types/components/gov-attachments/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const AttachmentsClass: {
+    root: string;
+    label: string;
+    list: string;
+};
+export declare const AttachmentsItemClass: {
+    root: string;
+    name: string;
+    file: string;
+    messages: string;
+};

package/dist/dist/types/components/gov-attachments/gov-attachments-item.d.d.ts

@@ -0,0 +1,4 @@
+export interface GovAttachmentsItemChangeEvent {
+    open: boolean;
+    element: HTMLGovAttachmentsItemElement;
+}

package/dist/dist/types/components/gov-attachments/gov-attachments-item.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class GovAttachmentsItem {
+    private h;
+    constructor();
+    readonly host: HTMLGovAttachmentsItemElement;
+    /**
+     * Adds accessible label for the remove button that is only shown for screen readers.
+     */
+    readonly accessibleRemoveLabel: string;
+    /**
+     * Indicates the id of a component that labels the remove button.
+     */
+    readonly accessibleRemoveLabelledBy: string;
+    /**
+     * Emitted when the file is removed
+     */
+    govRemove: EventEmitter<PointerEvent>;
+    componentDidRender(): Promise<void>;
+    render(): any;
+    /**
+     * Validate the accessible attributes of the component
+     */
+    validateAccessibility(): Promise<void>;
+}

package/dist/dist/types/components/gov-attachments/gov-attachments.d.ts

@@ -0,0 +1,19 @@
+export declare class GovAttachments {
+    private h;
+    constructor();
+    readonly host: HTMLGovAttachmentsElement;
+    /**
+     * Label of attachments section
+     */
+    readonly label: string;
+    /**
+     * Adds accessible label for the attachment section that is only shown for screen readers.
+     */
+    readonly wcagLabel: string;
+    componentDidRender(): Promise<void>;
+    render(): any;
+    /**
+     * Validate the WCAG attributes of the component
+     */
+    validateWcag(): Promise<void>;
+}

package/dist/dist/types/components/gov-backdrop/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const BackdropClass: {
+    root: string;
+    bg: string;
+};

package/dist/dist/types/components/gov-backdrop/gov-backdrop.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export declare class GovBackdrop {
+    private h;
+    constructor();
+    host: HTMLGovBackdropElement;
+    /**
+     * Determine if component should have inverse colors to be used on dark background.
+     */
+    readonly inverse: boolean;
+    /**
+     * Makes the backdrop component disabled.
+     */
+    readonly disabled: boolean;
+    /**
+     * Adds accessible label for the backdrop that is only shown for screen readers.
+     */
+    readonly accessibleLabel: string;
+    /**
+     * String of id's that indicate alternative labels elements
+     */
+    readonly accessibleLabelledBy: string;
+    /**
+     * Emitted when button clicks.
+     */
+    govClick: EventEmitter<MouseEvent>;
+    componentDidRender(): Promise<void>;
+    render(): any;
+    /**
+     * Validate the accessibility attributes of the component
+     */
+    validateAccessibility(): Promise<void>;
+}

package/dist/dist/types/components/gov-banner/constants.d.ts

@@ -0,0 +1,26 @@
+import { ValueOf } from "../../types/interfaces";
+import { Sizes } from "../../core/constants/sizes";
+export declare const BannerSizes: Pick<typeof Sizes, "_S" | "_M" | "_L" | "_XL">;
+export type BannerSizesType = `${ValueOf<typeof BannerSizes>}`;
+export declare enum BannerBackground {
+    SIMPLE = "simple",
+    WAVES = "waves",
+    STRIPES = "stripes",
+    LINES = "lines"
+}
+export type BannerBackgroundsType = `${ValueOf<typeof BannerBackground>}`;
+export declare enum BannerForeground {
+    IMAGE = "image",
+    LOGO = "logo",
+    ICON = "icon"
+}
+export type BannerForegroundsType = `${ValueOf<typeof BannerForeground>}`;
+export declare enum BannerTextColor {
+    LIGHT = "light",
+    DARK = "dark"
+}
+export type BannerTextColorsType = `${ValueOf<typeof BannerTextColor>}`;
+export declare const BannerClass: {
+    root: string;
+    content: string;
+};