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

package/dist/components/base/DsUiElement.d.ts

@@ -0,0 +1,16 @@
+import { type Theme } from '../ds-theme-provider/themeContext';
+import { type CSSResult, LitElement, type PropertyValues } from 'lit';
+export type ThemesStyles = {
+    [K in Theme]?: CSSResult | CSSResult[];
+};
+export declare class DsUiElement extends LitElement {
+    protected contextTheme?: Theme;
+    protected pubSubTheme: Theme;
+    protected theme: Theme;
+    static themesStyles?: ThemesStyles;
+    constructor();
+    private handleChangeTheme;
+    connectedCallback(): void;
+    updated(changed: PropertyValues): void;
+    private applyTheme;
+}

package/dist/components/base/UiKitElement.d.ts

@@ -0,0 +1,20 @@
+import { type Theme } from '../ds-theme-provider/themeContext';
+import { ComponentFactory } from '../../utils/componentFactory.ts';
+import { LitElement, PropertyValues } from 'lit';
+export declare class UiKitElement extends LitElement {
+    protected componentFactory: ComponentFactory;
+    protected contextTheme?: Theme;
+    protected pubSubTheme: Theme;
+    static componentName?: string;
+    private appliedConstructables?;
+    private appliedStyleTags?;
+    constructor();
+    protected get theme(): Theme | undefined;
+    private handleChangeTheme;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: PropertyValues): void;
+    protected getComponentNames(): string[];
+    private supportsAdoptedSheets;
+    private applyThemeStyles;
+}

package/dist/components/base/ds-base-input/ds-base-input.d.ts

@@ -0,0 +1,40 @@
+import { DsUiElement, type ThemesStyles } from '../DsUiElement.ts';
+import { type TemplateResult } from 'lit';
+import type { DsBaseInputAttrs } from './ds-base-input.types.ts';
+declare const DsBaseInput_base: typeof DsUiElement;
+export declare abstract class DsBaseInput extends DsBaseInput_base {
+    initialValue: DsBaseInputAttrs['initial-value'];
+    label: DsBaseInputAttrs['label'];
+    helperText: DsBaseInputAttrs['helper-text'];
+    errorText: DsBaseInputAttrs['error-text'];
+    disabled: DsBaseInputAttrs['disabled'];
+    success: DsBaseInputAttrs['success'];
+    mode: DsBaseInputAttrs['mode'];
+    size: DsBaseInputAttrs['size'];
+    protected _value: string;
+    protected focused: boolean;
+    protected inputField: HTMLInputElement;
+    protected firstUpdated(): void;
+    protected get value(): string;
+    protected set value(newValue: string);
+    static styles: import("lit").CSSResult[];
+    static themesStyles: ThemesStyles;
+    protected handleFocus: () => void;
+    protected handleBlur: () => void;
+    protected get classes(): {
+        [x: string]: boolean;
+        container: boolean;
+        focused: boolean;
+        error: boolean;
+        success: boolean;
+        disabled: boolean;
+    };
+    protected abstract handleInput: (event: Event) => void;
+    protected abstract labelTemplate: TemplateResult | symbol;
+    protected abstract inputTemplate: TemplateResult | symbol;
+    protected abstract iconTemplate: TemplateResult | symbol;
+    protected abstract dropdownTemplate: TemplateResult | symbol;
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    render(): TemplateResult<1>;
+}
+export {};

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

@@ -0,0 +1,11 @@
+import type { CommonAttrs } from '../../../types/types';
+export interface DsBaseInputAttrs extends CommonAttrs {
+    'initial-value'?: string;
+    label?: string;
+    'helper-text'?: string;
+    'error-text'?: string;
+    disabled?: boolean;
+    success?: boolean;
+    mode?: 'dark' | 'light';
+    size?: 'large' | 'small';
+}

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

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

package/dist/components/base/ds-base-input/styles/cupra.styles.d.ts

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

package/dist/components/base/ds-base-progress-bar/ds-base-progress-bar.d.ts

@@ -0,0 +1,15 @@
+import { DsUiElement, type ThemesStyles } from '../DsUiElement.ts';
+import type { DsBaseProgressBarAttrs } from './ds-base-progress-bar.types.ts';
+export declare class DsBaseProgressBar extends DsUiElement {
+    show: DsBaseProgressBarAttrs['show'];
+    mode: DsBaseProgressBarAttrs['mode'];
+    size: DsBaseProgressBarAttrs['size'];
+    static styles: import("lit").CSSResult[];
+    static themesStyles: ThemesStyles;
+    protected get classes(): {
+        [x: string]: boolean;
+        track: boolean;
+    };
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    protected get barTemplate(): import("lit").TemplateResult<1>;
+}

package/dist/components/base/ds-base-progress-bar/ds-base-progress-bar.types.d.ts

@@ -0,0 +1,6 @@
+import type { CommonAttrs } from '../../../types/types';
+export interface DsBaseProgressBarAttrs extends CommonAttrs {
+    show?: boolean;
+    mode?: 'dark' | 'light';
+    size?: 'large' | 'small';
+}

package/dist/components/base/ds-base-progress-bar/styles/common.styles.d.ts

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

package/dist/components/base/ds-base-progress-bar/styles/cupra-diagonal.styles.d.ts

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

package/dist/components/base/ds-base-progress-bar/styles/cupra.styles.d.ts

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

package/dist/components/base/ds-base-progress-bar/styles/seat.styles.d.ts

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

package/dist/components/ds-accordion/ds-accordion.d.ts

@@ -0,0 +1,29 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import type { DsAccordionAttrs } from '../ds-accordion/ds-accordion.types';
+import { type PropertyValues } from 'lit';
+export declare class DsAccordion extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    maxHeight: DsAccordionAttrs['max-height'];
+    open: DsAccordionAttrs['open'];
+    mode: DsAccordionAttrs['mode'];
+    size: DsAccordionAttrs['size'];
+    disabled: DsAccordionAttrs['disabled'];
+    _open: boolean;
+    firstUpdated(changedProps: PropertyValues): Promise<void>;
+    protected get containerClasses(): {
+        [x: string]: boolean;
+        container: boolean;
+        disabled: boolean;
+        open: boolean;
+    };
+    protected get dividerClasses(): {
+        [x: string]: boolean;
+        divider: boolean;
+    };
+    protected get openIconTemplate(): any;
+    protected get closeIconTemplate(): any;
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    protected handleKeyDown(event: KeyboardEvent): void;
+    protected handleToggle(event: ToggleEvent): void;
+    render(): import("lit").TemplateResult<1>;
+}

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

@@ -0,0 +1,8 @@
+import type { CommonAttrs } from '../../types/types';
+export interface DsAccordionAttrs extends CommonAttrs {
+    'max-height'?: number;
+    open?: boolean;
+    mode?: 'dark' | 'light';
+    size?: 'medium' | 'small' | (string & {});
+    disabled?: boolean;
+}

package/dist/components/ds-accordion/styles/common.styles.d.ts

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

package/dist/components/ds-accordion/theme-config.d.ts

@@ -0,0 +1,14 @@
+import type { Icons } from '../ds-icon/Icons.type.ts';
+interface IconNamesConfig {
+    open: Icons;
+    close: Icons;
+}
+interface BrandConfig {
+    'icon-names': IconNamesConfig;
+    'icon-button-variant'?: string;
+}
+type ThemeConfig = {
+    [brand: string]: BrandConfig;
+};
+export declare const themeConfig: ThemeConfig;
+export {};

package/dist/components/ds-avatar/ds-avatar.d.ts

@@ -0,0 +1,19 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { DsAvatarAttrs } from './ds-avatar.types.ts';
+export declare class DsAvatar extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    size: DsAvatarAttrs['size'];
+    name: DsAvatarAttrs['name'];
+    disabled: boolean;
+    private assignedImages?;
+    protected get iconTemplate(): any;
+    protected get initialsTemplate(): import("lit").TemplateResult<1>;
+    private getInitialsFromName;
+    private get classes();
+    private get hasImage();
+    private get mode();
+    private handleSlotChange;
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    handleKeyDown(event: KeyboardEvent): void;
+    render(): import("lit").TemplateResult<1>;
+}

package/dist/components/ds-avatar/ds-avatar.test.d.ts

@@ -0,0 +1,7 @@
+import type { DsAvatar } from './ds-avatar';
+import './ds-avatar';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-avatar': DsAvatar;
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { DsIconAttrs } from '../ds-icon/ds-icon.types';
+import { CommonAttrs } from '../../types/types';
+export type DsAvatarAttrs = {
+    'icon-name': DsIconAttrs['icon-name'];
+    size?: 'large' | 'medium' | 'small';
+    initials?: string;
+    name?: string;
+} & CommonAttrs;

package/dist/components/ds-avatar/styles/common.styles.d.ts

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

package/dist/components/ds-bullets/ds-bullets.d.ts

@@ -0,0 +1,14 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { nothing } from 'lit';
+import type { DsBulletsAttrs } from './ds-bullets.types';
+export declare class DsBullets extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    mode: DsBulletsAttrs['mode'];
+    bulletsNumber: DsBulletsAttrs['bullets-number'];
+    activeBulletIndex: DsBulletsAttrs['active-bullet-index'];
+    private handleClickChunk;
+    private get bulletsTemplate();
+    private get classes();
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    render(): typeof nothing | import("lit").TemplateResult<1>;
+}

package/dist/components/ds-bullets/ds-bullets.test.d.ts

@@ -0,0 +1,7 @@
+import './ds-bullets.ts';
+import { DsBullets } from '../ds-bullets/ds-bullets.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-bullets': DsBullets;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { CommonAttrs } from '../../types/types';
+export interface DsBulletsAttrs extends CommonAttrs {
+    mode?: 'dark' | 'light';
+    'bullets-number': number;
+    'active-bullet-index'?: number;
+}

package/dist/components/ds-bullets/styles/common.styles.d.ts

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

package/dist/components/ds-button/ds-button.d.ts

@@ -0,0 +1,39 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { nothing } from 'lit';
+import type { DsButtonAttrs } from './ds-button.types';
+declare const DsButton_base: (new (...args: any[]) => import("../../mixins/ViewportMixin").ViewportInterface) & typeof UiKitElement;
+export declare class DsButton extends DsButton_base {
+    static styles: import("lit").CSSResult[];
+    variant: DsButtonAttrs['variant'];
+    mode: DsButtonAttrs['mode'];
+    size: DsButtonAttrs['size'];
+    disabled: DsButtonAttrs['disabled'];
+    destructive: DsButtonAttrs['destructive'];
+    iconName: DsButtonAttrs['icon-name'];
+    htmlTagName: DsButtonAttrs['html-tag-name'];
+    href: DsButtonAttrs['href'];
+    rel: DsButtonAttrs['rel'];
+    target: DsButtonAttrs['target'];
+    type: DsButtonAttrs['type'];
+    iconPosition: DsButtonAttrs['icon-position'];
+    rounded: DsButtonAttrs['rounded'];
+    fullWidth: DsButtonAttrs['full-width'];
+    loading: DsButtonAttrs['loading'];
+    private closestForm;
+    protected firstUpdated(): void;
+    protected get classes(): {
+        [x: string]: boolean;
+        button: boolean;
+        custom: boolean;
+        rounded: boolean;
+        disabled: boolean;
+        destructive: boolean;
+        'full-width': boolean;
+    };
+    protected handleClick(event: Event): void;
+    protected get iconTemplate(): any;
+    protected get loadingTemplate(): typeof nothing | import("lit").TemplateResult<1>;
+    protected get cssTokens(): import("lit").HTMLTemplateResult;
+    render(): import("lit").TemplateResult<1>;
+}
+export {};

package/dist/components/ds-button/ds-button.test.d.ts

@@ -0,0 +1,7 @@
+import type { DsButton } from './ds-button';
+import './ds-button';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-button': DsButton;
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { DsIconAttrs } from '../ds-icon/ds-icon.types.ts';
+import type { CommonAttrs } from '../../types/types.ts';
+type Link = {
+    'html-tag-name': 'a';
+    href?: string;
+    rel?: string;
+    target?: string;
+};
+type Button = {
+    'html-tag-name'?: 'button';
+    href?: never;
+    rel?: never;
+    target?: never;
+};
+type CustomElement = {
+    'html-tag-name': 'custom';
+    href?: never;
+    rel?: never;
+    target?: never;
+};
+type HtmlElement = Link | Button | CustomElement;
+type SizeType = 'small' | 'medium' | 'large';
+type ResponsiveSize = SizeType | Record<string, SizeType>;
+export type DsButtonAttrs = {
+    variant?: string;
+    mode?: 'dark' | 'light';
+    disabled?: boolean;
+    destructive?: boolean;
+    'icon-name'?: DsIconAttrs['icon-name'];
+    size?: ResponsiveSize;
+    type?: 'button' | 'submit' | 'reset';
+    'icon-position'?: 'left' | 'right';
+    'icon-size'?: number;
+    rounded?: boolean;
+    'full-width'?: boolean;
+    loading?: boolean;
+} & HtmlElement & CommonAttrs;
+export {};

package/dist/components/ds-button/styles/common.styles.d.ts

@@ -0,0 +1,3 @@
+export declare const buttonStyles: import("lit").CSSResult;
+export declare const textStyles: import("lit").CSSResult;
+export declare const loadingDotsStyles: import("lit").CSSResult;

package/dist/components/ds-carousel-indicator/ds-carousel-indicator.d.ts

@@ -0,0 +1,12 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { nothing } from 'lit';
+import type { DsCarouselIndicatorAttrs } from './ds-carousel-indicator.types.ts';
+export declare class DsCarouselIndicator extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    selectorsNumber: DsCarouselIndicatorAttrs['selectors-number'];
+    selectedIndex: DsCarouselIndicatorAttrs['selected-index'];
+    private maxSelectorsShown;
+    private get classes();
+    private get selectorsTemplate();
+    render(): typeof nothing | import("lit").TemplateResult<1>;
+}

package/dist/components/ds-carousel-indicator/ds-carousel-indicator.types.d.ts

@@ -0,0 +1,5 @@
+import type { CommonAttrs } from '../../types/types';
+export type DsCarouselIndicatorAttrs = {
+    'selectors-number': number;
+    'selected-index'?: number;
+} & CommonAttrs;

package/dist/components/ds-carousel-indicator/styles/common.styles.d.ts

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

package/dist/components/ds-checkbox/ds-checkbox.d.ts

@@ -0,0 +1,31 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import type { DsCheckboxAttrs } from './ds-checkbox.types';
+declare const DsCheckbox_base: typeof UiKitElement;
+export declare class DsCheckbox extends DsCheckbox_base {
+    name: DsCheckboxAttrs['name'];
+    value: DsCheckboxAttrs['value'];
+    inputPlacement: DsCheckboxAttrs['input-placement'];
+    checked: DsCheckboxAttrs['checked'];
+    required: DsCheckboxAttrs['required'];
+    disabled: DsCheckboxAttrs['disabled'];
+    mode: DsCheckboxAttrs['mode'];
+    size: DsCheckboxAttrs['size'];
+    helperText: DsCheckboxAttrs['helper-text'];
+    infoText: DsCheckboxAttrs['info-text'];
+    forcedError: DsCheckboxAttrs['forced-error'];
+    invalidError: DsCheckboxAttrs['invalid-error'];
+    indeterminate: DsCheckboxAttrs['indeterminate'];
+    static styles: import("lit").CSSResult[];
+    private handleChange;
+    protected get classes(): {
+        [x: string]: boolean;
+        container: boolean;
+        disabled: boolean;
+        checked: boolean;
+        error: boolean;
+    };
+    protected get iconTemplate(): any;
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    render(): import("lit").TemplateResult<1>;
+}
+export {};

package/dist/components/ds-checkbox/ds-checkbox.test.d.ts

@@ -0,0 +1,7 @@
+import type { DsCheckbox } from './ds-checkbox';
+import './ds-checkbox.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-checkbox': DsCheckbox;
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { CommonAttrs } from '../../types/types';
+export interface DsCheckboxAttrs extends CommonAttrs {
+    name?: string;
+    value: string;
+    checked?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+    mode?: 'dark' | 'light';
+    size?: 'medium' | 'small';
+    'helper-text'?: string;
+    'info-text'?: string;
+    'forced-error'?: string;
+    'invalid-error'?: string;
+    indeterminate?: boolean;
+    'input-placement'?: 'left' | 'right';
+}

package/dist/components/ds-checkbox/styles/common.styles.d.ts

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

package/dist/components/ds-chip/ds-chip.d.ts

@@ -0,0 +1,21 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { type PropertyValues } from 'lit';
+import type { DsChipAttrs } from './ds-chip.types.ts';
+export declare class DsChip extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    value: DsChipAttrs['value'];
+    mode: DsChipAttrs['mode'];
+    size: DsChipAttrs['size'];
+    selected: DsChipAttrs['selected'];
+    deselectable: DsChipAttrs['deselectable'];
+    slottedText: string;
+    protected firstUpdated(changedProps: PropertyValues): void;
+    private get classes();
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    handleClick(): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    private handleClickIcon;
+    private handleKeyDownIcon;
+    protected get iconTemplate(): any;
+    render(): import("lit").TemplateResult<1>;
+}

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

@@ -0,0 +1,8 @@
+import type { CommonAttrs } from '../../types/types';
+export type DsChipAttrs = {
+    value: string;
+    mode?: 'dark' | 'light';
+    size?: 'large' | 'medium' | 'small';
+    selected?: boolean;
+    deselectable?: boolean;
+} & CommonAttrs;

package/dist/components/ds-chip/styles/common.styles.d.ts

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

package/dist/components/ds-chips/chipsContext.d.ts

@@ -0,0 +1,9 @@
+import type { DsChipsAttrs } from '../ds-chips/ds-chips.types.ts';
+export type ChipsData = {
+    selectedChips?: string[];
+    multiChoice?: DsChipsAttrs['multi-choice'];
+    size?: DsChipsAttrs['size'];
+};
+export declare const chipsContext: {
+    __context__: ChipsData;
+};

package/dist/components/ds-chips/ds-chips.d.ts

@@ -0,0 +1,27 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import { type PropertyValues, type TemplateResult } from 'lit';
+import type { DsChipsAttrs } from './ds-chips.types.ts';
+export declare class DsChips extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    selectedChips: DsChipsAttrs['selected-chips'];
+    multiChoice: DsChipsAttrs['multi-choice'];
+    size: DsChipsAttrs['size'];
+    mode: DsChipsAttrs['mode'];
+    private hasScrollLeft;
+    private hasScrollRight;
+    private chips;
+    private chipsContainer;
+    private resizeObserver;
+    protected firstUpdated(): void;
+    disconnectedCallback(): void;
+    private handleScrollNav;
+    private handleScrollLeft;
+    private handleScrollRight;
+    private getScrollButtonTemplate;
+    updated(changedProperties: PropertyValues): void;
+    private updateChildChips;
+    private get chipsContainerClasses();
+    handleSelect(event: CustomEvent): void;
+    handleDeselect(event: CustomEvent): void;
+    render(): TemplateResult<1>;
+}

package/dist/components/ds-chips/ds-chips.test.d.ts

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

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

@@ -0,0 +1,7 @@
+import type { CommonAttrs } from '../../types/types';
+export type DsChipsAttrs = {
+    'selected-chips'?: string[] | undefined[];
+    'multi-choice'?: boolean;
+    size?: 'large' | 'medium' | 'small';
+    mode?: 'dark' | 'light';
+} & CommonAttrs;

package/dist/components/ds-chips/styles/common.styles.d.ts

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

package/dist/components/ds-content-disclaimer/ds-content-disclaimer.test.d.ts

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

package/dist/components/ds-currency/ds-currency.d.ts

@@ -0,0 +1,28 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import type { DsCurrencyAttrs } from '../ds-currency/ds-currency.types.ts';
+import { nothing } from 'lit';
+export declare class DsCurrency extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    locale: DsCurrencyAttrs['locale'];
+    currencyCode: DsCurrencyAttrs['currency-code'];
+    amountText: DsCurrencyAttrs['amount-text'];
+    amountNumber: DsCurrencyAttrs['amount-number'];
+    minimumFractionDigits: DsCurrencyAttrs['minimum-fraction-digits'];
+    maximumFractionDigits: DsCurrencyAttrs['maximum-fraction-digits'];
+    period: DsCurrencyAttrs['period'];
+    note: DsCurrencyAttrs['note'];
+    thousandSeparator: DsCurrencyAttrs['thousand-separator'];
+    fractionSeparator: DsCurrencyAttrs['fraction-separator'];
+    amountSize: DsCurrencyAttrs['amount-size'];
+    amountWeight: DsCurrencyAttrs['amount-weight'];
+    currencySize: DsCurrencyAttrs['currency-size'];
+    currencyWeight: DsCurrencyAttrs['currency-weight'];
+    periodSize: DsCurrencyAttrs['period-size'];
+    periodWeight: DsCurrencyAttrs['period-weight'];
+    noteSize: DsCurrencyAttrs['note-size'];
+    noteWeight: DsCurrencyAttrs['note-weight'];
+    protected get valueTemplate(): import("lit").TemplateResult<1>;
+    protected get periodTemplate(): typeof nothing | import("lit").TemplateResult<1>;
+    protected get noteTemplate(): typeof nothing | import("lit").TemplateResult<1>;
+    render(): import("lit").TemplateResult<1>;
+}

package/dist/components/ds-currency/ds-currency.test.d.ts

@@ -0,0 +1,7 @@
+import type { DsCurrency } from './ds-currency';
+import './ds-currency.ts';
+declare global {
+    interface HTMLElementTagNameMap {
+        'ds-currency': DsCurrency;
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { Integer0To20, Locale } from '../../utils/formatNumber/formatNumber.ts';
+import type { CommonAttrs } from '../../types/types';
+type AmountText = {
+    'amount-text': string;
+    'amount-number'?: never;
+    'thousand-separator'?: never;
+    'fraction-separator'?: never;
+};
+type AmountNumber = {
+    'amount-text'?: never;
+    'amount-number': number;
+    'thousand-separator'?: string;
+    'fraction-separator'?: string;
+};
+type Amount = AmountText | AmountNumber;
+type FontSize = 'colossal' | 'huge' | 'large' | 'medium' | 'small' | 'tiny' | 'micro' | 'nano' | (string & {});
+type FontWeight = 'light' | 'regular' | 'medium' | 'book' | (string & {});
+export type DsCurrencyAttrs = CommonAttrs & Amount & {
+    locale: Locale;
+    'currency-code': string;
+    'minimum-fraction-digits'?: Integer0To20;
+    'maximum-fraction-digits'?: Integer0To20;
+    period?: 'era' | 'year' | 'month' | 'quarter' | 'weekOfYear' | 'weekday' | 'dayPeriod' | 'day' | 'hour' | 'minute' | 'second';
+    note?: string;
+    'amount-size'?: FontSize;
+    'amount-weight'?: FontWeight;
+    'currency-size'?: FontSize;
+    'currency-weight'?: FontWeight;
+    'period-size'?: FontSize;
+    'period-weight'?: FontWeight;
+    'note-size'?: FontSize;
+    'note-weight'?: FontWeight;
+};
+export {};

package/dist/components/ds-currency/styles/common.styles.d.ts

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