@cupra/ui-kit 0.0.1-placeholder → 0.2.0-canary.0

package/dist-react/components/ds-slider/ds-slider.d.ts

@@ -0,0 +1,74 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { type FormatedNumber } from '../../utils/formatNumber/formatNumber.ts';
+import { type PropertyValues } from 'lit';
+import type { DsSliderAttrs } from './ds-slider.types';
+declare const DsSlider_base: (new (...args: any[]) => import("../../mixins/ViewportMixin").ViewportInterface) & typeof UiKitElement;
+export declare class DsSlider extends DsSlider_base {
+    min: DsSliderAttrs['min'];
+    max: DsSliderAttrs['max'];
+    minLabel: DsSliderAttrs['min-label'];
+    maxLabel: DsSliderAttrs['max-label'];
+    step: DsSliderAttrs['step'];
+    initialValueMin: DsSliderAttrs['initial-value-min'];
+    initialValueMax: DsSliderAttrs['initial-value-max'];
+    mode: DsSliderAttrs['mode'];
+    locale: DsSliderAttrs['locale'];
+    localeMatcher: DsSliderAttrs['locale-matcher'];
+    unitSymbol: DsSliderAttrs['unit-symbol'];
+    unitSymbolPosition: DsSliderAttrs['unit-symbol-position'];
+    unitStyle: DsSliderAttrs['unit-style'];
+    currency: DsSliderAttrs['currency'];
+    unit: DsSliderAttrs['unit'];
+    useGrouping: DsSliderAttrs['use-grouping'];
+    minimumIntegerDigits: DsSliderAttrs['minimum-integer-digits'];
+    minimumFractionDigits: DsSliderAttrs['minimum-fraction-digits'];
+    maximumFractionDigits: DsSliderAttrs['maximum-fraction-digits'];
+    thousandSeparator: DsSliderAttrs['thousand-separator'];
+    fractionSeparator: DsSliderAttrs['fraction-separator'];
+    size: DsSliderAttrs['size'];
+    disabled: DsSliderAttrs['disabled'];
+    inputMinAriaLabel: DsSliderAttrs['input-min-aria-label'];
+    inputMaxAriaLabel: DsSliderAttrs['input-max-aria-label'];
+    protected track: HTMLInputElement;
+    protected valueMin: number;
+    protected valueMax: number;
+    protected activeThumb: 'min' | 'max' | null;
+    protected animationFrameRequest: number;
+    protected editingField?: 'min' | 'max' | null;
+    protected keyboardMode: boolean;
+    static styles: import("lit").CSSResult[];
+    disconnectedCallback(): void;
+    protected firstUpdated(changedProps: PropertyValues): void;
+    protected getTrackPct(value: number): number;
+    protected getNewValue: (event: MouseEvent | TouchEvent) => number;
+    protected setActiveThumb: (event: MouseEvent | TouchEvent) => void;
+    protected handleMouseMove: (event: MouseEvent | TouchEvent) => void;
+    protected handleMouseDown: (event: MouseEvent) => void;
+    protected handlePointerUp: () => void;
+    protected handleChange({ value, role }: {
+        value: number;
+        role: 'min' | 'max';
+    }): void;
+    protected formatNumber(value: number): FormatedNumber;
+    protected get rangeValuesTemplates(): import("lit").TemplateResult<1>;
+    protected getThumbTemplate(id: 1 | 2): import("lit").TemplateResult<1>;
+    protected get thumbTemplates(): import("lit").TemplateResult<1>;
+    protected get trackRangeTemplate(): import("lit").TemplateResult<1>;
+    private handleKeydown;
+    private handlePointerOrMouseDown;
+    protected onInputFocus: (event: FocusEvent, id: 1 | 2) => void;
+    protected commitInputValue: (event: Event, id: 1 | 2) => void;
+    protected onInputBlur: (event: FocusEvent) => void;
+    protected onInputKeyDown: (event: KeyboardEvent, id: 1 | 2) => void;
+    protected onThumbKeyDown: (event: KeyboardEvent, id: 1 | 2) => void;
+    protected getInputTemplate(id: number): import("lit").TemplateResult<1>;
+    protected get inputsTemplate(): import("lit").TemplateResult<1>;
+    protected get containerClasses(): {
+        [x: string]: boolean;
+        container: boolean;
+        disabled: boolean;
+    };
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    render(): import("lit").TemplateResult<1>;
+}
+export {};

package/dist-react/components/ds-slider/ds-slider.test.d.ts

@@ -0,0 +1,8 @@
+import './ds-slider.ts';
+import type { DsSlider } from '../ds-slider/ds-slider.ts';
+import '../ds-theme-provider/ds-theme-provider.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-slider': DsSlider;
+    }
+}

package/dist-react/components/ds-slider/ds-slider.types.d.ts

@@ -0,0 +1,53 @@
+import type { Currency, Decimal, Integer0To20, Integer1To21, Locale, NoUnit, Percent, Unit } from '../../utils/formatNumber/formatNumber.ts';
+import type { CommonAttrs } from '../../types/types';
+type SliderCurrency = Omit<Currency, 'style'> & {
+    'unit-style': 'currency';
+    'unit-symbol'?: never;
+};
+type SliderDecimal = Omit<Decimal, 'style'> & {
+    'unit-style': 'decimal';
+    'unit-symbol'?: never;
+};
+type SliderPercent = Omit<Percent, 'style'> & {
+    'unit-style': 'percent';
+    'unit-symbol'?: never;
+};
+type SliderUnit = Omit<Unit, 'style'> & {
+    'unit-style': 'unit';
+    'unit-symbol'?: never;
+};
+type SliderNoUnit = Omit<NoUnit, 'style'> & {
+    'unit-style'?: never;
+    'unit-symbol'?: never;
+};
+type SliderCustomUnit = Omit<NoUnit, 'style'> & {
+    'unit-style'?: never;
+    'unit-symbol': string;
+};
+type SliderUnitStyle = SliderCurrency | SliderDecimal | SliderPercent | SliderUnit | SliderNoUnit | SliderCustomUnit;
+type SliderSize = 'medium' | 'large';
+export type ResponsiveSliderSize = SliderSize | Record<string, SliderSize>;
+export type DsSliderAttrs = CommonAttrs & {
+    min?: number;
+    max?: number;
+    'min-label'?: string;
+    'max-label'?: string;
+    step?: number;
+    'initial-value-min'?: number;
+    'initial-value-max'?: number;
+    mode?: 'dark' | 'light';
+    size?: ResponsiveSliderSize;
+    disabled?: boolean;
+    'unit-symbol-position'?: 'left' | 'right';
+    locale?: Locale;
+    localeMatcher?: 'lookup' | 'best fit';
+    'minimum-integer-digits'?: Integer1To21;
+    'minimum-fraction-digits'?: Integer0To20;
+    'maximum-fraction-digits'?: Integer0To20;
+    'thousand-separator'?: string;
+    'fraction-separator'?: string;
+    'use-grouping'?: 'auto' | boolean;
+    'input-min-aria-label'?: string;
+    'input-max-aria-label'?: string;
+} & SliderUnitStyle;
+export {};

package/dist-react/components/ds-slider/styles/common.styles.d.ts

@@ -0,0 +1,5 @@
+export declare const commonStyles: import("lit").CSSResult;
+export declare const currentValueStyles: import("lit").CSSResult;
+export declare const rangeValueStyles: import("lit").CSSResult;
+export declare const trackStyles: import("lit").CSSResult;
+export declare const thumbStyles: import("lit").CSSResult;

package/dist-react/components/ds-slider/utils/getStepValue/getStepValue.d.ts

@@ -0,0 +1,14 @@
+type GetStepValue = (props: {
+    step?: number;
+    min?: number;
+    max?: number;
+    proposedValue: number;
+    role: 'min' | 'max';
+    currentValues: Record<string, number>;
+}) => {
+    stepValue: number;
+    minLimit: number;
+    maxLimit: number;
+};
+export declare const getStepValue: GetStepValue;
+export {};

package/dist-react/components/ds-slider/utils/getStepValue/getStepValue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-react/components/ds-slider/utils/roundToDecimals/roundToDecimals.d.ts

@@ -0,0 +1,6 @@
+type RoundToDecimals = (props: {
+    value: number;
+    fractionDigits: number;
+}) => number;
+export declare const roundToDecimals: RoundToDecimals;
+export {};

package/dist-react/components/ds-slider/utils/roundToDecimals/roundToDecimals.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-react/components/ds-static-box/ds-static-box.d.ts

@@ -0,0 +1,13 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { DsStaticBoxAttrs } from '../ds-static-box/ds-static-box.types.ts';
+declare const DsStaticBox_base: (new (...args: any[]) => import("../../mixins/ViewportMixin.ts").ViewportInterface) & typeof UiKitElement;
+export declare class DsStaticBox extends DsStaticBox_base {
+    static styles: import("lit").CSSResult[];
+    size: DsStaticBoxAttrs['size'];
+    headerItems: Array<Node>;
+    footerItems: Array<Node>;
+    private get classes();
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    render(): import("lit").TemplateResult<1>;
+}
+export {};

package/dist-react/components/ds-static-box/ds-static-box.test.d.ts

@@ -0,0 +1,8 @@
+import type { DsStaticBox } from './ds-static-box';
+import './ds-static-box.ts';
+import '../ds-theme-provider/ds-theme-provider.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-static-box': DsStaticBox;
+    }
+}

package/dist-react/components/ds-static-box/ds-static-box.types.d.ts

@@ -0,0 +1,4 @@
+import { CommonAttrs } from '../../types/types';
+export type DsStaticBoxAttrs = {
+    size?: 'small' | 'medium' | 'large';
+} & CommonAttrs;

package/dist-react/components/ds-static-box/styles/common.styles.d.ts

@@ -0,0 +1 @@
+export declare const commonStyles: import("lit").CSSResult;

package/dist-react/components/ds-stepper/ds-stepper.d.ts

@@ -0,0 +1,9 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { nothing } from 'lit';
+export declare class DsStepper extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    steps: number;
+    currentStep: number;
+    private get classes();
+    render(): typeof nothing | import("lit").TemplateResult<1>;
+}

package/dist-react/components/ds-stepper/ds-stepper.test.d.ts

@@ -0,0 +1,8 @@
+import { DsStepper } from '../ds-stepper/ds-stepper.ts';
+import './ds-stepper.ts';
+import '../ds-theme-provider/ds-theme-provider.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-stepper': DsStepper;
+    }
+}

package/dist-react/components/ds-stepper/ds-stepper.types.d.ts

@@ -0,0 +1,5 @@
+import type { CommonAttrs } from '../../types/types';
+export type DsStepperAttrs = {
+    steps?: number;
+    'current-step'?: number;
+} & CommonAttrs;

package/dist-react/components/ds-stepper/styles/common.styles.d.ts

@@ -0,0 +1 @@
+export declare const commonStyles: import("lit").CSSResult;

package/dist-react/components/ds-tabs/ds-tabs.d.ts

@@ -0,0 +1,47 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { type PropertyValues, type TemplateResult } from 'lit';
+import type { DsTabsAttrs } from './ds-tabs.types';
+export declare class DsTabs extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    selectedTab: DsTabsAttrs['selected-tab'];
+    mode: DsTabsAttrs['mode'];
+    variant: string;
+    size: DsTabsAttrs['size'];
+    disabled: DsTabsAttrs['disabled'];
+    private focusedTabIndex;
+    private nav;
+    private handleKeyDown;
+    private tabs;
+    private panels;
+    private hasScrollLeft;
+    private hasScrollRight;
+    private resizeObserver;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private handleScrollNav;
+    private handleScrollLeft;
+    private handleScrollRight;
+    private getScrollButtonTemplate;
+    protected firstUpdated(): void;
+    updated(changedProperties: PropertyValues): void;
+    protected handleTabsSlotchange(e: any): void;
+    protected handlePanelSlotchange(e: any): void;
+    private setTabsFocusable;
+    protected selectTab(selectedTab: number): void;
+    protected setupTabAccessibility(): void;
+    protected handleFocus: (event: FocusEvent) => void;
+    protected handleBlur: () => void;
+    protected handleChangeSelectedTab(newSelectedTab: number): void;
+    protected handleSelect(e: MouseEvent): void;
+    protected get classes(): {
+        [x: string]: boolean;
+        container: boolean;
+        disabled: boolean;
+    };
+    protected get navContainerClasses(): {
+        'nav-container': boolean;
+        'scroll-left': boolean;
+        'scroll-right': boolean;
+    };
+    render(): TemplateResult<1>;
+}

package/dist-react/components/ds-tabs/ds-tabs.test.d.ts

@@ -0,0 +1,8 @@
+import './ds-tabs.ts';
+import { DsTabs } from '../ds-tabs/ds-tabs.ts';
+import '../ds-theme-provider/ds-theme-provider.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-tabs': DsTabs;
+    }
+}

package/dist-react/components/ds-tabs/ds-tabs.types.d.ts

@@ -0,0 +1,11 @@
+import type { CommonAttrs } from '../../types/types';
+export type SlottedContent = HTMLElement & {
+    selected?: boolean;
+};
+export interface DsTabsAttrs extends CommonAttrs {
+    'selected-tab'?: number;
+    mode?: 'dark' | 'light';
+    size?: string;
+    variant?: string;
+    disabled?: boolean;
+}

package/dist-react/components/ds-tabs/styles/common.styles.d.ts

@@ -0,0 +1,4 @@
+export declare const commonStyles: import("lit").CSSResult;
+export declare const navigationStyles: import("lit").CSSResult;
+export declare const tabsStyles: import("lit").CSSResult;
+export declare const panelsStyles: import("lit").CSSResult;

package/dist-react/components/ds-tabs/theme-config.d.ts

@@ -0,0 +1,8 @@
+type BrandConfig = {
+    'icon-button-variant': string;
+};
+export type ThemeConfig = {
+    [brand: string]: BrandConfig;
+};
+export declare const themeConfig: ThemeConfig;
+export {};

package/dist-react/components/ds-tag/ds-tag.d.ts

@@ -0,0 +1,23 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import type { DsTagAttrs } from '../ds-tag/ds-tag.types';
+import { nothing } from 'lit';
+export declare class DsTag extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    show: DsTagAttrs['show'];
+    clickableIcon: DsTagAttrs['clickable-icon'];
+    iconName: DsTagAttrs['icon-name'];
+    iconPosition: DsTagAttrs['icon-position'];
+    color: DsTagAttrs['color'];
+    protected onClickHandler: Function;
+    protected get classes(): {
+        [x: string]: boolean;
+        container: boolean;
+    };
+    protected get iconClasses(): {
+        icon: boolean;
+        clicable: boolean;
+    };
+    private handleClickIcon;
+    protected get iconTemplate(): any;
+    render(): typeof nothing | import("lit").TemplateResult<1>;
+}

package/dist-react/components/ds-tag/ds-tag.test.d.ts

@@ -0,0 +1,8 @@
+import type { DsTag } from './ds-tag';
+import './ds-tag';
+import '../ds-theme-provider/ds-theme-provider.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-tag': DsTag;
+    }
+}

package/dist-react/components/ds-tag/ds-tag.types.d.ts

@@ -0,0 +1,9 @@
+import type { DsIconAttrs } from '../ds-icon/ds-icon.types';
+import type { CommonAttrs } from '../../types/types';
+export interface DsTagAttrs extends CommonAttrs {
+    show?: boolean;
+    'clickable-icon'?: boolean;
+    'icon-name'?: DsIconAttrs['icon-name'];
+    'icon-position'?: 'left' | 'right';
+    color?: 'moonlate' | 'white' | 'copper' | 'rio-green' | 'electric' | (string & {});
+}

package/dist-react/components/ds-tag/styles/common.styles.d.ts

@@ -0,0 +1,2 @@
+export declare const commonStyles: import("lit").CSSResult;
+export declare const iconStyles: import("lit").CSSResult;

package/dist-react/components/ds-text/ds-text.d.ts

@@ -0,0 +1,18 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { type TemplateResult } from 'lit';
+import type { DsTextAttrs } from './ds-text.types.ts';
+export declare class DsText extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    size: DsTextAttrs['size'];
+    weight: DsTextAttrs['weight'];
+    variant: DsTextAttrs['variant'];
+    htmlTagName: DsTextAttrs['html-tag-name'];
+    value: DsTextAttrs['value'];
+    mode: DsTextAttrs['mode'];
+    color: DsTextAttrs['color'];
+    uppercase: DsTextAttrs['uppercase'];
+    private get classes();
+    private get customElementTemplate();
+    protected get styles(): import("lit").HTMLTemplateResult;
+    render(): TemplateResult<1>;
+}

package/dist-react/components/ds-text/ds-text.test.d.ts

@@ -0,0 +1,8 @@
+import type { DsText } from './ds-text.ts';
+import './ds-text.ts';
+import '../ds-theme-provider/ds-theme-provider.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-text': DsText;
+    }
+}

package/dist-react/components/ds-text/ds-text.types.d.ts

@@ -0,0 +1,14 @@
+import type { CommonAttrs } from '../../types/types';
+export type TextSize = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';
+export type TextWeight = 'light' | 'regular' | 'medium' | 'book' | string;
+export type TextVariant = 'display' | 'headline' | 'body';
+export type DsTextAttrs = {
+    size?: TextSize;
+    weight?: TextWeight;
+    variant?: TextVariant;
+    'html-tag-name'?: string;
+    value?: string;
+    mode?: 'dark' | 'light';
+    color?: string;
+    uppercase?: boolean;
+} & CommonAttrs;

package/dist-react/components/ds-text/styles/common.styles.d.ts

@@ -0,0 +1 @@
+export declare const commonStyles: import("lit").CSSResult;

package/dist-react/components/ds-text-input/ds-text-input.d.ts

@@ -0,0 +1,22 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { nothing } from 'lit';
+import type { DsTextInputAttrs } from './ds-text-input.types.ts';
+declare const DsTextInput_base: (new (...args: any[]) => import("../../mixins/inputStatesMixin.ts").InputStatesInterface) & typeof UiKitElement;
+export declare class DsTextInput extends DsTextInput_base {
+    static styles: import("lit").CSSResult[];
+    private keyboardMode;
+    size: DsTextInputAttrs['size'];
+    helperText: DsTextInputAttrs['helper-text'];
+    forcedError: DsTextInputAttrs['forced-error'];
+    invalidError: DsTextInputAttrs['invalid-error'];
+    dataAriaLabelRemoveButton: DsTextInputAttrs['data-aria-label-remove-button'];
+    protected handleClickIcon: () => void;
+    private get classes();
+    render(): import("lit").TemplateResult<1>;
+    protected get iconTemplate(): any;
+    protected get lengthTemplate(): typeof nothing | import("lit").TemplateResult<1>;
+    protected get helperTextTemplate(): typeof nothing | import("lit").TemplateResult<1>;
+    protected get forcedErrorTemplate(): typeof nothing | import("lit").TemplateResult<1>;
+    protected get invalidErrorTemplate(): typeof nothing | import("lit").TemplateResult<1>;
+}
+export {};

package/dist-react/components/ds-text-input/ds-text-input.test.d.ts

@@ -0,0 +1,9 @@
+import type { DsTextInput } from './ds-text-input.ts';
+import './ds-text-input.ts';
+import '../ds-theme-provider/ds-theme-provider.ts';
+import '../ds-icon-button/ds-icon-button.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-text-input': DsTextInput;
+    }
+}

package/dist-react/components/ds-text-input/ds-text-input.types.d.ts

@@ -0,0 +1,8 @@
+import type { CommonAttrs } from '../../types/types';
+export type DsTextInputAttrs = {
+    size?: 'medium' | 'small';
+    'helper-text'?: string;
+    'forced-error'?: string;
+    'invalid-error'?: string;
+    'data-aria-label-remove-button'?: string;
+} & CommonAttrs;

package/dist-react/components/ds-text-input/styles/common.styles.d.ts

@@ -0,0 +1 @@
+export declare const commonStyles: import("lit").CSSResult;

package/dist-react/components/ds-textarea/ds-textarea.d.ts

@@ -0,0 +1,21 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { nothing } from 'lit';
+import type { DsTextareaAttrs } from './ds-textarea.types.ts';
+declare const DsTextarea_base: (new (...args: any[]) => import("../../mixins/inputStatesMixin.ts").InputStatesInterface) & typeof UiKitElement;
+export declare class DsTextarea extends DsTextarea_base {
+    static styles: import("lit").CSSResult[];
+    private keyboardMode;
+    size: DsTextareaAttrs['size'];
+    helperText: DsTextareaAttrs['helper-text'];
+    forcedError: DsTextareaAttrs['forced-error'];
+    invalidError: DsTextareaAttrs['invalid-error'];
+    mode: DsTextareaAttrs['mode'];
+    protected onInputReady(nativeInput: HTMLInputElement | HTMLTextAreaElement): void;
+    private get classes();
+    render(): import("lit").TemplateResult<1>;
+    protected get lengthTemplate(): typeof nothing | import("lit").TemplateResult<1>;
+    protected get helperTextTemplate(): typeof nothing | import("lit").TemplateResult<1>;
+    protected get forcedErrorTemplate(): typeof nothing | import("lit").TemplateResult<1>;
+    protected get invalidErrorTemplate(): typeof nothing | import("lit").TemplateResult<1>;
+}
+export {};

package/dist-react/components/ds-textarea/ds-textarea.test.d.ts

@@ -0,0 +1,8 @@
+import type { DsTextarea } from './ds-textarea.ts';
+import './ds-textarea.ts';
+import '../ds-theme-provider/ds-theme-provider.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-textarea': DsTextarea;
+    }
+}

package/dist-react/components/ds-textarea/ds-textarea.types.d.ts

@@ -0,0 +1,8 @@
+import type { CommonAttrs } from '../../types/types';
+export type DsTextareaAttrs = {
+    size?: 'medium' | 'small';
+    'helper-text'?: string;
+    'forced-error'?: string;
+    'invalid-error'?: string;
+    mode?: 'dark' | 'light';
+} & CommonAttrs;

package/dist-react/components/ds-textarea/styles/common.styles.d.ts

@@ -0,0 +1 @@
+export declare const commonStyles: import("lit").CSSResult;

package/dist-react/components/ds-theme-provider/ds-theme-provider.d.ts

@@ -0,0 +1,14 @@
+import type { DsThemeProviderAttrs } from '../ds-theme-provider/ds-theme-provider.types.ts';
+import { LitElement, type PropertyValues, nothing } from 'lit';
+export declare class DsThemeProvider extends LitElement {
+    loadFonts: DsThemeProviderAttrs['load-fonts'];
+    loadStyles: DsThemeProviderAttrs['load-styles'];
+    theme: DsThemeProviderAttrs['theme'];
+    private cssLoaded;
+    private loadedFonts;
+    protected updated(changedProperties: PropertyValues): void;
+    private loadThemeFonts;
+    private loadThemeFont;
+    private loadThemeStyles;
+    render(): typeof nothing | import("lit").TemplateResult<1>;
+}

package/dist-react/components/ds-theme-provider/ds-theme-provider.types.d.ts

@@ -0,0 +1,7 @@
+import type { Theme } from '../ds-theme-provider/themeContext.ts';
+import type { CommonAttrs } from '../../types/types';
+export interface DsThemeProviderAttrs extends CommonAttrs {
+    theme?: Theme;
+    'load-fonts': boolean;
+    'load-styles': boolean;
+}

package/dist-react/components/ds-theme-provider/themeContext.d.ts

@@ -0,0 +1,4 @@
+export type Theme = 'cupra' | 'cupra-diagonal' | 'seat';
+export declare const themeContext: {
+    __context__: Theme;
+};

package/dist-react/components/ds-toast/ds-toast.d.ts

@@ -0,0 +1,17 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import type { DsToastAttrs } from './ds-toast.types.ts';
+export declare class DsToast extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    position: DsToastAttrs['position'];
+    private toasts;
+    private unsubscribe;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private handleAnimationEnd;
+    private getToastMessageTemplate;
+    protected get containerClasses(): {
+        [x: string]: boolean;
+        'toast-container': boolean;
+    };
+    render(): import("lit").TemplateResult<1>;
+}

package/dist-react/components/ds-toast/ds-toast.test.d.ts

@@ -0,0 +1,9 @@
+import type { DsToast } from './ds-toast';
+import '../ds-theme-provider/ds-theme-provider.ts';
+import '../ds-toast-message/ds-toast-message.ts';
+import './ds-toast.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-toast': DsToast;
+    }
+}

package/dist-react/components/ds-toast/ds-toast.types.d.ts

@@ -0,0 +1,18 @@
+import type { CommonAttrs } from '../../types/types.ts';
+export type ToastStatus = 'success' | 'error' | 'warning' | 'info' | 'default';
+export interface ToastOptions {
+    id?: string;
+    title?: string;
+    text?: string;
+    status?: ToastStatus;
+    duration?: number;
+    referenceId?: string;
+}
+export interface Toast extends ToastOptions {
+    timeoutId?: number;
+    exiting?: boolean;
+}
+export type ToastManagerSubscriber = (toasts: Toast[]) => void;
+export type DsToastAttrs = {
+    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+} & CommonAttrs;

package/dist-react/components/ds-toast/styles/common.styles.d.ts

@@ -0,0 +1,2 @@
+export declare const containerStyles: import("lit").CSSResult;
+export declare const toastStyles: import("lit").CSSResult;

package/dist-react/components/ds-toast/utils/ToastManager.d.ts

@@ -0,0 +1,27 @@
+import type { Toast, ToastManagerSubscriber, ToastOptions } from '../ds-toast.types';
+type AddEvent = CustomEvent<ToastOptions>;
+type RemoveEvent = CustomEvent<Extract<ToastOptions, 'id | referenceId'>>;
+declare global {
+    interface WindowEventMap {
+        'toast:add': AddEvent;
+        'toast:remove': RemoveEvent;
+    }
+}
+export declare const generateId: () => string;
+declare class ToastManager {
+    private static instance;
+    private toasts;
+    private subscribers;
+    private defaultDuration;
+    constructor();
+    private initialize;
+    static getInstance(): ToastManager;
+    private handleAddToast;
+    private handleRemoveToast;
+    removeToast(id: string): void;
+    getToasts(): Toast[];
+    subscribe(subscriber: ToastManagerSubscriber): () => void;
+    private notifySubscribers;
+}
+export declare const toastManager: ToastManager;
+export {};

package/dist-react/components/ds-toast/utils/ToastManager.test.d.ts

@@ -0,0 +1 @@
+export {};