@cupra/ui-kit 2.0.0-canary.17 → 2.0.0-canary.171

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

@@ -1,9 +1,11 @@
 import { UiKitElement } from '../base/UiKitElement.ts';
+import '../ds-text-input/ds-text-input.ts';
 import { type FormatedNumber } from '../../utils/formatNumber/formatNumber.ts';
 import { type PropertyValues } from 'lit';
-import type { DsSliderAttrs } from './ds-slider.types';
+import type { DsSliderAttrs, DsSliderVariant } from './ds-slider.types';
 declare const DsSlider_base: (new (...args: any[]) => import("../../mixins/ViewportMixin").ViewportInterface) & typeof UiKitElement;
 export declare class DsSlider extends DsSlider_base {
+    variant: DsSliderVariant;
     min: DsSliderAttrs['min'];
     max: DsSliderAttrs['max'];
     minLabel: DsSliderAttrs['min-label'];
@@ -11,6 +13,8 @@ export declare class DsSlider extends DsSlider_base {
     step: DsSliderAttrs['step'];
     initialValueMin: DsSliderAttrs['initial-value-min'];
     initialValueMax: DsSliderAttrs['initial-value-max'];
+    valueMin: DsSliderAttrs['value-min'];
+    valueMax: DsSliderAttrs['value-max'];
     mode: DsSliderAttrs['mode'];
     locale: DsSliderAttrs['locale'];
     localeMatcher: DsSliderAttrs['locale-matcher'];
@@ -30,16 +34,29 @@ export declare class DsSlider extends DsSlider_base {
     inputMinAriaLabel: DsSliderAttrs['input-min-aria-label'];
     inputMaxAriaLabel: DsSliderAttrs['input-max-aria-label'];
     protected track: HTMLInputElement;
-    protected valueMin: number;
-    protected valueMax: number;
+    protected _valueMin: number;
+    protected _valueMax: number;
+    protected editingField?: 'min' | 'max' | null;
     protected activeThumb: 'min' | 'max' | null;
     protected animationFrameRequest: number;
-    protected editingField?: 'min' | 'max' | null;
     protected keyboardMode: boolean;
+    private _initialValuesApplied;
     static styles: import("lit").CSSResult[];
+    protected get isRange(): boolean;
+    private get sliderSizeToTextInputSize();
+    private isControlled;
+    private getRoleById;
+    private get currentValues();
+    private computeStep;
+    protected willUpdate(changedProps: PropertyValues): void;
     disconnectedCallback(): void;
     protected firstUpdated(changedProps: PropertyValues): void;
+    private applyInitialValues;
     protected getTrackPct(value: number): number;
+    protected get thumbRadius(): number;
+    private static readonly THUMB_RADIUS_CSS_VAR;
+    private trackPosition;
+    private trackWidth;
     protected getNewValue: (event: MouseEvent | TouchEvent) => number;
     protected setActiveThumb: (event: MouseEvent | TouchEvent) => void;
     protected handleMouseMove: (event: MouseEvent | TouchEvent) => void;
@@ -61,14 +78,16 @@ export declare class DsSlider extends DsSlider_base {
     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 getInputTemplate(id: 1 | 2): import("lit").HTMLTemplateResult;
     protected get inputsTemplate(): import("lit").TemplateResult<1>;
+    protected getSecondaryInputTemplate(id: 1 | 2): import("lit").HTMLTemplateResult;
+    protected get secondaryInputsTemplate(): import("lit").TemplateResult<1>;
     protected get containerClasses(): {
         [x: string]: boolean;
         container: boolean;
         disabled: boolean;
     };
-    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    protected get styleTokens(): import("lit").TemplateResult<1>;
     render(): import("lit").TemplateResult<1>;
 }
 export {};

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

@@ -1,5 +1,10 @@
+import { type Viewports } from '../../utils/breakpoints.ts';
 import type { Currency, Decimal, Integer0To20, Integer1To21, Locale, NoUnit, Percent, Unit } from '../../utils/formatNumber/formatNumber.ts';
 import type { CommonAttrs } from '../../types/types';
+export type DsSliderVariant = 'primary' | 'secondary';
+type PresetSize = 'large' | 'medium';
+type Size = PresetSize | string;
+type ResponsiveSize = Partial<Record<Viewports, Size>>;
 type SliderCurrency = Omit<Currency, 'style'> & {
     'unit-style': 'currency';
     'unit-symbol'?: never;
@@ -25,16 +30,32 @@ type SliderCustomUnit = Omit<NoUnit, 'style'> & {
     'unit-symbol': string;
 };
 type SliderUnitStyle = SliderCurrency | SliderDecimal | SliderPercent | SliderUnit | SliderNoUnit | SliderCustomUnit;
+type UncontrolledMin = {
+    'initial-value-min'?: number;
+    'value-min'?: never;
+};
+type ControlledMin = {
+    'initial-value-min'?: never;
+    'value-min'?: number;
+};
+type UncontrolledMax = {
+    'initial-value-max'?: number;
+    'value-max'?: never;
+};
+type ControlledMax = {
+    'initial-value-max'?: never;
+    'value-max'?: number;
+};
+type SliderValueProps = (UncontrolledMin | ControlledMin) & (UncontrolledMax | ControlledMax);
 export type DsSliderAttrs = CommonAttrs & {
+    variant?: DsSliderVariant;
     min?: number;
     max?: number;
     'min-label'?: string;
     'max-label'?: string;
     step?: number;
-    'initial-value-min'?: number;
-    'initial-value-max'?: number;
     mode?: 'dark' | 'light';
-    size?: 'medium' | 'large' | string;
+    size?: Size | ResponsiveSize;
     disabled?: boolean;
     'unit-symbol-position'?: 'left' | 'right';
     locale?: Locale;
@@ -47,5 +68,5 @@ export type DsSliderAttrs = CommonAttrs & {
     'use-grouping'?: 'auto' | boolean;
     'input-min-aria-label'?: string;
     'input-max-aria-label'?: string;
-} & SliderUnitStyle;
+} & SliderValueProps & SliderUnitStyle;
 export {};

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

@@ -3,3 +3,4 @@ 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;
+export declare const inputResetStyles: import("lit").CSSResult;

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

@@ -6,8 +6,16 @@ export declare class DsStaticBox extends DsStaticBox_base {
     size: DsStaticBoxAttrs['size'];
     headerItems: Array<Node>;
     footerItems: Array<Node>;
+    mainElement: HTMLElement;
+    showTopShadow: boolean;
+    showBottomShadow: boolean;
+    private cleanupScrollObserver?;
     private get classes();
-    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    private get mainWrapperClasses();
+    protected get styleTokens(): import("lit").TemplateResult<1>;
+    private onSlotChange;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
     render(): import("lit").TemplateResult<1>;
 }
 export {};

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

@@ -1,4 +1,9 @@
+import { type Viewports } from '../../utils/breakpoints.ts';
 import { CommonAttrs } from '../../types/types';
+type PresetSize = 'large' | 'medium' | 'small';
+type Size = PresetSize | string;
+type ResponsiveSize = Partial<Record<Viewports, Size>>;
 export type DsStaticBoxAttrs = {
-    size?: 'small' | 'medium' | 'large' | string;
+    size?: Size | ResponsiveSize;
 } & CommonAttrs;
+export {};

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

@@ -4,6 +4,11 @@ export declare class DsStepper extends UiKitElement {
     static styles: import("lit").CSSResult[];
     steps: number;
     currentStep: number;
+    sectionName: string;
     private get classes();
-    render(): typeof nothing | import("lit").TemplateResult<1>;
+    private get clampedCurrentStep();
+    private get sectionNumberText();
+    private get headerTemplate();
+    private get stepsRowTemplate();
+    render(): import("lit").TemplateResult<1> | typeof nothing;
 }

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

@@ -2,4 +2,5 @@ import type { CommonAttrs } from '../../types/types';
 export type DsStepperAttrs = {
     steps?: number;
     'current-step'?: number;
+    'section-name'?: string;
 } & CommonAttrs;

package/dist/types/components/ds-table/ds-table.d.ts

@@ -0,0 +1,13 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { nothing } from 'lit';
+export declare class DsTable extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    emptyMessage: string;
+    private hasHeaderContent;
+    private hasBodyContent;
+    private handleHeaderSlotChange;
+    private handleBodySlotChange;
+    private get columnCount();
+    private get showEmptyState();
+    render(): import("lit").TemplateResult<1> | typeof nothing;
+}

package/dist/types/components/ds-table/ds-table.types.d.ts

@@ -0,0 +1,4 @@
+import type { CommonAttrs } from '../../types/types';
+export interface DsTableAttrs extends CommonAttrs {
+    'empty-message'?: string;
+}

package/dist/types/components/ds-table/styles/common.styles.d.ts

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

package/dist/types/components/ds-table-cell/ds-table-cell.d.ts

@@ -0,0 +1,7 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import type { TableCellVariant } from './ds-table-cell.types.ts';
+export declare class DsTableCell extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    variant: TableCellVariant;
+    render(): import("lit").TemplateResult<1>;
+}

package/dist/types/components/ds-table-cell/ds-table-cell.types.d.ts

@@ -0,0 +1,5 @@
+import type { CommonAttrs } from '../../types/types';
+export type TableCellVariant = 'header' | 'default' | 'alternative';
+export interface DsTableCellAttrs extends CommonAttrs {
+    variant?: TableCellVariant;
+}

package/dist/types/components/ds-table-cell/styles/common.styles.d.ts

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

package/dist/types/components/ds-table-row/ds-table-row.d.ts

@@ -0,0 +1,7 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+export declare class DsTableRow extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    private columnCount;
+    private handleSlotChange;
+    render(): import("lit").TemplateResult<1>;
+}

package/dist/types/components/ds-table-row/ds-table-row.types.d.ts

@@ -0,0 +1,3 @@
+import type { CommonAttrs } from '../../types/types';
+export interface DsTableRowAttrs extends CommonAttrs {
+}

package/dist/types/components/ds-table-row/styles/common.styles.d.ts

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

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

@@ -1,9 +1,13 @@
 import { UiKitElement } from '../base/UiKitElement.ts';
+import '../ds-icon-button/ds-icon-button.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'];
+    _selectedTab: DsTabsAttrs['selected-tab'];
+    private _selectedTabState;
+    get selectedTab(): number;
+    set selectedTab(value: DsTabsAttrs['selected-tab']);
     mode: DsTabsAttrs['mode'];
     variant: string;
     size: DsTabsAttrs['size'];
@@ -40,6 +44,7 @@ export declare class DsTabs extends UiKitElement {
     };
     protected get navContainerClasses(): {
         'nav-container': boolean;
+        'ds-blur': boolean;
         'scroll-left': boolean;
         'scroll-right': boolean;
     };

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

@@ -5,7 +5,7 @@ export type SlottedContent = HTMLElement & {
 export interface DsTabsAttrs extends CommonAttrs {
     'selected-tab'?: number;
     mode?: 'dark' | 'light';
-    size?: string;
+    size?: 'large' | 'medium' | string;
     variant?: string;
     disabled?: boolean;
 }

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

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

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

@@ -1,9 +1,19 @@
 import type { DsIconAttrs } from '../ds-icon/ds-icon.types';
 import type { CommonAttrs } from '../../types/types';
-export interface DsTagAttrs extends CommonAttrs {
+export type DsTagColor = 'moonlate' | 'white' | 'copper' | 'rio-green' | 'electric' | 'yellow' | 'red' | 'green' | 'black' | (string & {});
+export type DsTagVariant = 'default' | 'contrast' | 'accent-01' | 'accent-02' | 'accent-03' | 'warning' | 'error' | 'success' | 'disabled';
+type DsTagBaseAttrs = CommonAttrs & {
     show?: boolean;
     'clickable-icon'?: boolean;
     'icon-name'?: DsIconAttrs['icon-name'];
     'icon-position'?: 'left' | 'right';
-    color?: 'moonlate' | 'white' | 'copper' | 'rio-green' | 'electric' | (string & {});
-}
+};
+export type DsTagAttrs = DsTagBaseAttrs & ({
+    /** @deprecated Use `variant` instead. */
+    color?: DsTagColor;
+    variant?: never;
+} | {
+    variant?: DsTagVariant;
+    color?: never;
+});
+export {};

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

@@ -1,18 +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 {
+declare const DsText_base: (new (...args: any[]) => import("../../mixins/ViewportMixin.ts").ViewportInterface) & typeof UiKitElement;
+export declare class DsText extends DsText_base {
     static styles: import("lit").CSSResult[];
     size: DsTextAttrs['size'];
-    weight: DsTextAttrs['weight'];
+    emphasis: DsTextAttrs['emphasis'];
     variant: DsTextAttrs['variant'];
     htmlTagName: DsTextAttrs['html-tag-name'];
     value: DsTextAttrs['value'];
     mode: DsTextAttrs['mode'];
     color: DsTextAttrs['color'];
     uppercase: DsTextAttrs['uppercase'];
+    slotedNodes: Array<Node>;
     private get classes();
-    private get customElementTemplate();
-    protected get styles(): import("lit").HTMLTemplateResult;
-    render(): TemplateResult<1>;
+    render(): import("lit").TemplateResult;
 }
+export {};

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

@@ -1,12 +1,12 @@
 import type { CommonAttrs } from '../../types/types';
-export type TextSize = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';
-export type TextWeight = 'light' | 'regular' | 'medium' | 'book' | string;
+export type TextSize = 'xxsmall' | 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';
+export type TextEmphasis = 'primary' | 'secondary' | 'tertiary';
 export type TextVariant = 'display' | 'headline' | 'body';
 export type DsTextAttrs = {
     size?: TextSize;
-    weight?: TextWeight;
+    emphasis?: TextEmphasis;
     variant?: TextVariant;
-    'html-tag-name'?: string;
+    'html-tag-name'?: 'span' | 'p' | 'strong' | 'em' | 'small' | 'label' | 'div' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
     value?: string;
     mode?: 'dark' | 'light';
     color?: string;

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

@@ -1,4 +1,5 @@
 import { UiKitElement } from '../base/UiKitElement.ts';
+import '../ds-icon-button/ds-icon-button.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;
@@ -9,14 +10,17 @@ export declare class DsTextInput extends DsTextInput_base {
     helperText: DsTextInputAttrs['helper-text'];
     forcedError: DsTextInputAttrs['forced-error'];
     invalidError: DsTextInputAttrs['invalid-error'];
+    readonlyText: DsTextInputAttrs['readonly-text'];
     dataAriaLabelRemoveButton: DsTextInputAttrs['data-aria-label-remove-button'];
+    hideClearButton: boolean;
     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>;
+    protected get iconTemplate(): typeof nothing | import("lit").HTMLTemplateResult;
+    protected get lengthTemplate(): import("lit").TemplateResult<1> | typeof nothing;
+    protected get helperTextTemplate(): import("lit").TemplateResult<1> | typeof nothing;
+    protected get forcedErrorTemplate(): import("lit").TemplateResult<1> | typeof nothing;
+    protected get readonlyTextTemplate(): import("lit").TemplateResult<1> | typeof nothing;
+    protected get invalidErrorTemplate(): import("lit").TemplateResult<1> | typeof nothing;
 }
 export {};

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

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

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

@@ -9,13 +9,15 @@ export declare class DsTextarea extends DsTextarea_base {
     helperText: DsTextareaAttrs['helper-text'];
     forcedError: DsTextareaAttrs['forced-error'];
     invalidError: DsTextareaAttrs['invalid-error'];
+    readonlyText: DsTextareaAttrs['readonly-text'];
     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>;
+    protected get lengthTemplate(): import("lit").TemplateResult<1> | typeof nothing;
+    protected get helperTextTemplate(): import("lit").TemplateResult<1> | typeof nothing;
+    protected get forcedErrorTemplate(): import("lit").TemplateResult<1> | typeof nothing;
+    protected get readonlyTextTemplate(): import("lit").TemplateResult<1> | typeof nothing;
+    protected get invalidErrorTemplate(): import("lit").TemplateResult<1> | typeof nothing;
 }
 export {};

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

@@ -1,8 +1,14 @@
+import { type Viewports } from '../../utils/breakpoints.ts';
 import type { CommonAttrs } from '../../types/types';
+type PresetSize = 'large' | 'medium';
+type Size = PresetSize | string;
+type ResponsiveSize = Partial<Record<Viewports, Size>>;
 export type DsTextareaAttrs = {
-    size?: 'medium' | 'small';
+    size?: Size | ResponsiveSize;
     'helper-text'?: string;
     'forced-error'?: string;
     'invalid-error'?: string;
+    'readonly-text'?: string;
     mode?: 'dark' | 'light';
 } & CommonAttrs;
+export {};

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

@@ -3,6 +3,7 @@ import { LitElement, type PropertyValues, nothing } from 'lit';
 export declare class DsThemeProvider extends LitElement {
     loadFonts: DsThemeProviderAttrs['load-fonts'];
     loadStyles: DsThemeProviderAttrs['load-styles'];
+    loadUnusedStyles: DsThemeProviderAttrs['load-unused-styles'];
     theme: DsThemeProviderAttrs['theme'];
     private cssLoaded;
     private loadedFonts;
@@ -10,5 +11,6 @@ export declare class DsThemeProvider extends LitElement {
     private loadThemeFonts;
     private loadThemeFont;
     private loadThemeStyles;
-    render(): typeof nothing | import("lit").TemplateResult<1>;
+    private applyUnusedStyles;
+    render(): import("lit").TemplateResult<1> | typeof nothing;
 }

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

@@ -4,4 +4,5 @@ export interface DsThemeProviderAttrs extends CommonAttrs {
     theme: Theme;
     'load-fonts': boolean;
     'load-styles': boolean;
+    'load-unused-styles'?: boolean;
 }

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

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

package/dist/types/components/ds-theme-switch/ds-theme-switch.d.ts

@@ -0,0 +1,12 @@
+import { LitElement, nothing } from 'lit';
+export declare class DsThemeSwitch extends LitElement {
+    private activeTheme?;
+    private getMatchingTemplate;
+    private getDefaultTemplate;
+    render(): import("lit").TemplateResult<1> | typeof nothing;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-theme-switch': DsThemeSwitch;
+    }
+}

package/dist/types/components/ds-theme-switch/ds-theme-switch.types.d.ts

@@ -0,0 +1,2 @@
+import type { CommonAttrs } from '../../types/types';
+export type DsThemeSwitchAttrs = CommonAttrs;

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

@@ -1,4 +1,5 @@
 import { UiKitElement } from '../base/UiKitElement.ts';
+import '../ds-toast-message/ds-toast-message.ts';
 import type { DsToastAttrs } from './ds-toast.types.ts';
 export declare class DsToast extends UiKitElement {
     static styles: import("lit").CSSResult[];

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

@@ -1,4 +1,6 @@
 import { UiKitElement } from '../base/UiKitElement.ts';
+import '../ds-icon-button/ds-icon-button.ts';
+import '../ds-icon/ds-icon.ts';
 import { nothing } from 'lit';
 import type { DsToastMessageAttrs } from './ds-toast-message.types.ts';
 export declare class DsToastMessage extends UiKitElement {
@@ -14,7 +16,7 @@ export declare class DsToastMessage extends UiKitElement {
         [x: string]: boolean;
         container: boolean;
     };
-    protected get iconTemplate(): any;
-    protected get closeButtonTemplate(): any;
-    render(): typeof nothing | import("lit").TemplateResult<1>;
+    protected get iconTemplate(): import("lit").HTMLTemplateResult;
+    protected get closeButtonTemplate(): import("lit").HTMLTemplateResult;
+    render(): import("lit").TemplateResult<1> | typeof nothing;
 }

package/dist/types/components/ds-toggle-switch/ds-toggle-switch.d.ts

@@ -3,14 +3,17 @@ import type { DsToggleSwitchAttrs } from '../ds-toggle-switch/ds-toggle-switch.t
 export declare class DsToggleSwitch extends UiKitElement {
     static styles: import("lit").CSSResult[];
     size: DsToggleSwitchAttrs['size'];
-    checked: DsToggleSwitchAttrs['checked'];
+    _checked: DsToggleSwitchAttrs['checked'];
+    private _checkedState;
+    get checked(): boolean;
+    set checked(value: DsToggleSwitchAttrs['checked']);
     disabled: DsToggleSwitchAttrs['disabled'];
     mode: DsToggleSwitchAttrs['mode'];
     dataAriaLabel: DsToggleSwitchAttrs['data-aria-label'];
     protected handleClick(): void;
-    protected handleClickOff(): void;
-    protected handleClickOn(): void;
-    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    protected handleClickOff(event: Event): void;
+    protected handleClickOn(event: Event): void;
+    protected get styleTokens(): import("lit").TemplateResult<1>;
     protected get labelClasses(): {
         [x: string]: boolean;
         container: boolean;

package/dist/types/components/ds-toggle-switch/ds-toggle-switch.types.d.ts

@@ -3,6 +3,6 @@ export interface DsToggleSwitchAttrs extends CommonAttrs {
     checked?: boolean;
     disabled?: boolean;
     mode?: 'dark' | 'light';
-    size?: 'medium' | 'small';
+    size?: 'large' | 'medium' | string;
     'data-aria-label'?: string;
 }

package/dist/types/components/ds-tooltip/ds-tooltip.d.ts

@@ -1,9 +1,7 @@
 import { UiKitElement } from '../base/UiKitElement.ts';
 import { type Placement } from '@floating-ui/dom';
-import { nothing } from 'lit';
 import type { DsTooltipAttrs } from './ds-tooltip.types';
-declare const DsTooltip_base: (new (...args: any[]) => import("../../mixins/ViewportMixin").ViewportInterface) & typeof UiKitElement;
-export declare class DsTooltip extends DsTooltip_base {
+export declare class DsTooltip extends UiKitElement {
     static styles: import("lit").CSSResult[];
     mode: DsTooltipAttrs['mode'];
     show: DsTooltipAttrs['show'];
@@ -25,6 +23,7 @@ export declare class DsTooltip extends DsTooltip_base {
     protected updatePosition(): void;
     protected handleKeyDown: () => void;
     protected handlePointerDown: () => void;
+    protected handleTooltipPointerDown: (event: Event) => void;
     protected handleResize: (params?: any) => void | Function;
     protected get arrowClasses(): {
         [x: string]: boolean;
@@ -47,8 +46,8 @@ export declare class DsTooltip extends DsTooltip_base {
     };
     protected handleClose: () => void;
     protected get arrowTemplate(): import("lit").TemplateResult<1>;
-    protected get tooltipTemplate(): typeof nothing | import("lit").TemplateResult<1>;
-    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    protected get tooltipTemplate(): import("lit").TemplateResult<1>;
+    protected get styleTokens(): import("lit").TemplateResult<1>;
     protected handleAnchorPointerDown: (event: PointerEvent) => void;
     protected handleAnchorMouseOver: () => void;
     protected handleAnchorMouseOut: () => void;
@@ -57,4 +56,3 @@ export declare class DsTooltip extends DsTooltip_base {
     protected handlePressOutside: (event: MouseEvent) => void;
     render(): import("lit").TemplateResult<1>;
 }
-export {};

package/dist/types/components/ds-value-unit/ds-value-unit.d.ts

@@ -0,0 +1,9 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import type { ValueFontWeight, ValueUnitSize } from '../ds-value-unit/ds-value-unit.types.ts';
+export declare class DsValueUnit extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    size: ValueUnitSize;
+    valueWeight: ValueFontWeight;
+    unitWeight: ValueFontWeight;
+    render(): import("lit").TemplateResult<1>;
+}

package/dist/types/components/ds-value-unit/ds-value-unit.types.d.ts

@@ -0,0 +1,8 @@
+import type { CommonAttrs } from '../../types/types';
+export type ValueUnitSize = 'colossal' | 'huge' | 'big' | 'large' | 'medium' | 'small' | 'micro' | 'nano';
+export type ValueFontWeight = 'regular' | 'light';
+export type DsValueUnitAttrs = CommonAttrs & {
+    size?: ValueUnitSize;
+    'value-weight'?: ValueFontWeight;
+    'unit-weight'?: ValueFontWeight;
+};

package/dist/types/components/ds-value-unit/styles/common.styles.d.ts

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