@nectary/components 2.12.0 → 2.12.2

package/lib/esm/rich-textarea/types.d.ts

@@ -0,0 +1,48 @@
+import type { TSinchElementReact } from '../types';
+export type TRichTextareaSelection = {
+    italic: boolean;
+    bold: boolean;
+    strikethrough: boolean;
+    codetag: boolean;
+    link: boolean;
+    ulist: boolean;
+    olist: boolean;
+};
+export type TSinchRichTextareaElement = HTMLElement & {
+    /** Value */
+    value: string;
+    /** Text that appears in the text field when it has no value set */
+    placeholder: string | null;
+    insertText(value: string): void;
+    insertLink(text: string, href: string): void;
+    formatItalic(): void;
+    formatBold(): void;
+    formatStrikethrough(): void;
+    formatCodeTag(): void;
+    formatOrderedList(): void;
+    formatUnorderedList(): void;
+    /** Change value event */
+    addEventListener(type: '-change', listener: (e: CustomEvent<string>) => void): void;
+    /** Focus event */
+    addEventListener(type: '-focus', listener: (e: CustomEvent<void>) => void): void;
+    /** Blur event */
+    addEventListener(type: '-blur', listener: (e: CustomEvent<void>) => void): void;
+    addEventListener(type: '-selection', listener: (e: CustomEvent<TRichTextareaSelection>) => void): void;
+    /** Value */
+    setAttribute(name: 'value', value: string): void;
+    /** Text that appears in the text field when it has no value set */
+    setAttribute(name: 'placeholder', value: string): void;
+};
+export type TSinchRichTextareaReact = TSinchElementReact<TSinchRichTextareaElement> & {
+    /** Value */
+    value: string;
+    /** Text that appears in the text field when it has no value set */
+    placeholder?: string;
+    'aria-label': string;
+    /** Change value handler */
+    'on-change'?: (e: CustomEvent<string>) => void;
+    /** Focus handler */
+    'on-focus'?: (e: CustomEvent<void>) => void;
+    /** Blur handler */
+    'on-blur'?: (e: CustomEvent<void>) => void;
+};

package/lib/esm/rich-textarea/utils.d.ts

@@ -0,0 +1,39 @@
+import type { TRichTextareaSelection } from './types';
+import type { TMarkdownParseVisitor } from '../utils';
+export interface TRichTextareaRoot extends HTMLElement {
+    nodeName: 'DIV';
+}
+export type TRange = {
+    endContainer: Node;
+    endOffset: number;
+    startContainer: Node;
+    startOffset: number;
+};
+export type TRichTextareaFormatInputType = 'formatItalic' | 'formatBold' | 'formatStrikeThrough' | 'formatCodeTag';
+export declare const formatInline: (formatType: TRichTextareaFormatInputType, range: TRange) => TActionResult;
+export declare const formatIndent: (range: TRange) => TActionResult;
+export declare const formatOutdent: (range: TRange) => TActionResult;
+export declare const formatList: (isOrdered: boolean, range: TRange) => TActionResult;
+export type TActionResult = {
+    prevent: false;
+} | {
+    range: TRange | null;
+    prevent: true;
+};
+export declare const deleteContentBackward: ($root: TRichTextareaRoot, range: TRange) => TActionResult;
+export declare const insertLink: ($root: TRichTextareaRoot, text: string, href: string, range: TRange) => TActionResult;
+export declare const insertLineBreak: (range: TRange) => TActionResult;
+export declare const insertText: ($root: TRichTextareaRoot, data: string | null, range: TRange) => TActionResult;
+export declare const insertFromPaste: (data: string, range: Readonly<TRange>, visitor: TMarkdownParseVisitor) => TActionResult;
+export declare const handleEmojiMousedown: ($n: Node) => TActionResult;
+export declare const getBeginRange: ($root: TRichTextareaRoot) => TRange;
+export declare const getEndRange: ($root: TRichTextareaRoot) => TRange;
+export declare const getSelectionInfo: (range: TRange) => TRichTextareaSelection;
+export declare const isSelectionEqual: (a: TRichTextareaSelection | null, b: TRichTextareaSelection | null) => boolean;
+export declare const isEditorEmpty: ($root: TRichTextareaRoot) => boolean;
+export declare const serializeMarkdown: ($root: TRichTextareaRoot, range: Readonly<TRange> | null) => string;
+export declare const createParseVisitor: (doc: Document) => {
+    updateEmojiBaseUrl(url: string | null): void;
+    createVisitor(): TMarkdownParseVisitor;
+};
+export declare const setBrowserCaret: ({ startContainer, startOffset, endContainer, endOffset }: TRange) => void;

package/lib/esm/segment/index.d.ts

@@ -0,0 +1,12 @@
+import '../title';
+import type { TSinchSegmentElement, TSinchSegmentReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-segment': TSinchSegmentReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-segment': TSinchSegmentElement;
+    }
+}

package/lib/esm/segment/types.d.ts

@@ -0,0 +1,16 @@
+import type { TRect, TSinchElementReact } from '../types';
+import type { TSinchSize } from '../utils/size';
+export type TSinchSegmentElement = HTMLElement & {
+    caption: string;
+    collapsed: boolean;
+    size: TSinchSize;
+    readonly collapseButtonRect: TRect | null;
+    setAttribute(name: 'caption', value: string): void;
+    setAttribute(name: 'collapsed', value: ''): void;
+    setAttribute(name: 'size', value: TSinchSize): void;
+};
+export type TSinchSegmentReact = TSinchElementReact<TSinchSegmentElement> & {
+    caption: string;
+    collapsed?: boolean;
+    size?: TSinchSize;
+};

package/lib/esm/segment/utils.d.ts

@@ -0,0 +1,3 @@
+import type { TSinchTitleType } from '../title/types';
+import type { TSinchSize } from '../utils/size';
+export declare const getTitleTypeFromSize: (size: TSinchSize) => TSinchTitleType;

package/lib/esm/segment-collapse/index.d.ts

@@ -0,0 +1,13 @@
+import '../icon';
+import '../icon-button';
+import type { TSinchSegmentExpandElement, TSinchSegmentExpandReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-segment-collapse': TSinchSegmentExpandReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-segment-collapse': TSinchSegmentExpandElement;
+    }
+}

package/lib/esm/segment-collapse/types.d.ts

@@ -0,0 +1,11 @@
+import type { TSinchElementReact } from '../types';
+export type TSinchSegmentExpandElement = HTMLElement & {
+    value: boolean;
+    addEventListener(type: '-change', listener: (e: CustomEvent<boolean>) => void): void;
+    setAttribute(name: 'value', value: string): void;
+};
+export type TSinchSegmentExpandReact = TSinchElementReact<TSinchSegmentExpandElement> & {
+    value: boolean;
+    'aria-label': string;
+    'on-change'?: (e: CustomEvent<boolean>) => void;
+};

package/lib/esm/segmented-control/index.d.ts

@@ -0,0 +1,11 @@
+import type { TSinchSegmentedControlElement, TSinchSegmentedControlReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-segmented-control': TSinchSegmentedControlReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-segmented-control': TSinchSegmentedControlElement;
+    }
+}

package/lib/esm/segmented-control/types.d.ts

@@ -0,0 +1,11 @@
+import type { TSinchElementReact } from '../types';
+export type TSinchSegmentedControlElement = HTMLElement & {
+    value: string;
+    addEventListener(type: '-change', listener: (e: CustomEvent<string>) => void): void;
+    setAttribute(name: 'value', value: string): void;
+};
+export type TSinchSegmentedControlReact = TSinchElementReact<TSinchSegmentedControlElement> & {
+    value: string;
+    'aria-label': string;
+    'on-change'?: (e: CustomEvent<string>) => void;
+};

package/lib/esm/segmented-control-option/index.d.ts

@@ -0,0 +1,11 @@
+import type { TSinchSegmentedControlOptionElement, TSinchSegmentedControlOptionReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-segmented-control-option': TSinchSegmentedControlOptionReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-segmented-control-option': TSinchSegmentedControlOptionElement;
+    }
+}

package/lib/esm/segmented-control-option/types.d.ts

@@ -0,0 +1,19 @@
+import type { TSinchElementReact } from '../types';
+export type TSinchSegmentedControlOptionElement = HTMLElement & {
+    value: string;
+    disabled: boolean;
+    text: string;
+    addEventListener(type: '-focus', listener: (e: CustomEvent<void>) => void): void;
+    addEventListener(type: '-blur', listener: (e: CustomEvent<void>) => void): void;
+    setAttribute(name: 'value', value: string): void;
+    setAttribute(name: 'text', value: string): void;
+    setAttribute(name: 'disabled', value: ''): void;
+};
+export type TSinchSegmentedControlOptionReact = TSinchElementReact<TSinchSegmentedControlOptionElement> & {
+    value: string;
+    text: string;
+    disabled?: boolean;
+    'aria-label': string;
+    'on-focus'?: (e: CustomEvent<void>) => void;
+    'on-blur'?: (e: CustomEvent<void>) => void;
+};

package/lib/esm/segmented-icon-control/index.d.ts

@@ -0,0 +1,11 @@
+import type { TSinchSegmentedIconControlElement, TSinchSegmentedIconControlReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-segmented-icon-control': TSinchSegmentedIconControlReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-segmented-icon-control': TSinchSegmentedIconControlElement;
+    }
+}

package/lib/esm/segmented-icon-control/types.d.ts

@@ -0,0 +1,14 @@
+import type { TSinchElementReact } from '../types';
+export type TSinchSegmentedIconControlElement = HTMLElement & {
+    value: string;
+    multiple: boolean;
+    addEventListener(type: '-change', listener: (e: CustomEvent<string>) => void): void;
+    setAttribute(name: 'value', value: string): void;
+    setAttribute(name: 'multiple', value: ''): void;
+};
+export type TSinchSegmentedIconControlReact = TSinchElementReact<TSinchSegmentedIconControlElement> & {
+    value: string;
+    multiple?: boolean;
+    'aria-label': string;
+    'on-change'?: (e: CustomEvent<string>) => void;
+};

package/lib/esm/segmented-icon-control-option/index.d.ts

@@ -0,0 +1,11 @@
+import type { TSinchSegmentedIconControlOptionElement, TSinchSegmentedIconControlOptionReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-segmented-icon-control-option': TSinchSegmentedIconControlOptionReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-segmented-icon-control-option': TSinchSegmentedIconControlOptionElement;
+    }
+}

package/lib/esm/segmented-icon-control-option/types.d.ts

@@ -0,0 +1,16 @@
+import type { TSinchElementReact } from '../types';
+export type TSinchSegmentedIconControlOptionElement = HTMLElement & {
+    value: string;
+    disabled: boolean;
+    addEventListener(type: '-focus', listener: (e: CustomEvent<void>) => void): void;
+    addEventListener(type: '-blur', listener: (e: CustomEvent<void>) => void): void;
+    setAttribute(name: 'value', value: string): void;
+    setAttribute(name: 'disabled', value: ''): void;
+};
+export type TSinchSegmentedIconControlOptionReact = TSinchElementReact<TSinchSegmentedIconControlOptionElement> & {
+    value: string;
+    disabled?: boolean;
+    'aria-label': string;
+    'on-focus'?: (e: CustomEvent<void>) => void;
+    'on-blur'?: (e: CustomEvent<void>) => void;
+};

package/lib/esm/select-button/index.d.ts

@@ -0,0 +1,13 @@
+import '../text';
+import '../icon';
+import type { TSinchSelectButtonElement, TSinchSelectButtonReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-select-button': TSinchSelectButtonReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-select-button': TSinchSelectButtonElement;
+    }
+}

package/lib/esm/select-button/types.d.ts

@@ -0,0 +1,50 @@
+import type { TSinchElementReact } from '../types';
+import type { TSinchSize } from '../utils/size';
+export type TSinchSelectButtonElement = HTMLElement & {
+    /** Text */
+    text: string;
+    /** Text that appears in the text field when it has no text set */
+    placeholder: string;
+    /** Invalid state */
+    invalid: boolean;
+    /** Disabled */
+    disabled: boolean;
+    /** Size, `m` by default */
+    size: TSinchSize;
+    /** Click event */
+    addEventListener(type: '-click', listener: (e: CustomEvent<void>) => void): void;
+    /** Focus event */
+    addEventListener(type: '-focus', listener: (e: CustomEvent<void>) => void): void;
+    /** Blur event */
+    addEventListener(type: '-blur', listener: (e: CustomEvent<void>) => void): void;
+    /** Text */
+    setAttribute(name: 'text', value: string): void;
+    /** Text that appears in the text field when it has no value set */
+    setAttribute(name: 'placeholder', value: string): void;
+    /** Invalid state */
+    setAttribute(name: 'invalid', value: ''): void;
+    /** Disabled */
+    setAttribute(name: 'disabled', value: ''): void;
+    /** Size, `m` by default */
+    setAttribute(name: 'size', value: TSinchSize): void;
+};
+export type TSinchSelectButtonReact = TSinchElementReact<TSinchSelectButtonElement> & {
+    /** Text */
+    text: string;
+    /** Label that is used for a11y` */
+    'aria-label': string;
+    /** Text that appears in the text field when it has no text set */
+    placeholder: string;
+    /** Invalid state */
+    invalid?: boolean;
+    /** Disabled */
+    disabled?: boolean;
+    /** Size, `m` by default */
+    size?: TSinchSize;
+    /** Click handler */
+    'on-click': (e: CustomEvent<void>) => void;
+    /** Focus handler */
+    'on-focus'?: (e: CustomEvent<void>) => void;
+    /** Blur handler */
+    'on-blur'?: (e: CustomEvent<void>) => void;
+};

package/lib/esm/select-menu/index.d.ts

@@ -0,0 +1,15 @@
+import '../input';
+import '../icon-button';
+import '../icon';
+import '../text';
+import type { TSinchSelectMenuElement, TSinchSelectMenuReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-select-menu': TSinchSelectMenuReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-select-menu': TSinchSelectMenuElement;
+    }
+}

package/lib/esm/select-menu/types.d.ts

@@ -0,0 +1,41 @@
+import type { TSinchElementReact } from '../types';
+export type TSinchSelectMenuElement = HTMLElement & {
+    /** Selected value, CSV when multiple */
+    value: string;
+    /** How many rows to show and scroll the rest */
+    rows: number | null;
+    /** Allows multiple selection */
+    multiple: boolean;
+    /** Enforce the search bar appearing, by default it appears above a certain number of options  */
+    searchable: boolean | null;
+    /** Text for search bar's placeholder */
+    'search-placeholder': string;
+    /** Change value event */
+    addEventListener(type: '-change', listener: (e: CustomEvent<string>) => void): void;
+    /** Change value event */
+    addEventListener(type: '-search-change', listener: (e: CustomEvent<string>) => void): void;
+    /** Selected value, CSV when multiple */
+    setAttribute(name: 'value', value: string): void;
+    /** How many rows to show and scroll the rest */
+    setAttribute(name: 'rows', value: string): void;
+    /** Allows multiple selection */
+    setAttribute(name: 'multiple', value: ''): void;
+};
+export type TSinchSelectMenuReact = TSinchElementReact<TSinchSelectMenuElement> & {
+    /** Selected value, CSV when multiple */
+    value: string;
+    /** How many rows to show and scroll the rest */
+    rows?: number;
+    /** Allows multiple selection */
+    multiple?: boolean;
+    /** Enforce the search bar appearing, by default it appears above a certain number of options  */
+    searchable?: boolean | null;
+    /** Text for search bar's placeholder */
+    'search-placeholder'?: string;
+    /** Label that is used for a11y */
+    'aria-label': string;
+    /** Change value handler */
+    'on-search-change'?: (e: CustomEvent<string>) => void;
+    /** Change value handler */
+    'on-change'?: (e: CustomEvent<string>) => void;
+};

package/lib/esm/select-menu-option/index.d.ts

@@ -0,0 +1,28 @@
+import '../icon';
+import '../text';
+import { NectaryElement } from '../utils';
+import type { TSinchSelectMenuOptionElement, TSinchSelectMenuOptionReact } from './types';
+export declare class SelectMenuOption extends NectaryElement {
+    #private;
+    constructor();
+    connectedCallback(): void;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, oldVal: string | null, newVal: string | null): void;
+    set value(value: string);
+    get value(): string;
+    set text(value: string);
+    get text(): string;
+    set disabled(isDisabled: boolean);
+    get disabled(): boolean;
+    matchesSearch(searchValue: string): boolean;
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-select-menu-option': TSinchSelectMenuOptionReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-select-menu-option': TSinchSelectMenuOptionElement;
+    }
+}

package/lib/esm/select-menu-option/types.d.ts

@@ -0,0 +1,26 @@
+import type { TSinchElementReact } from '../types';
+export type TSinchSelectMenuOptionElement = HTMLElement & {
+    /** Value */
+    value: string;
+    /** Display text */
+    text: string;
+    /** Disabled state */
+    disabled: boolean;
+    matchesSearch(value: string): boolean;
+    /** Value */
+    setAttribute(name: 'value', value: string): void;
+    /** Display text */
+    setAttribute(name: 'text', value: string): void;
+    /** Disabled state */
+    setAttribute(name: 'disabled', value: ''): void;
+};
+export type TSinchSelectMenuOptionReact = TSinchElementReact<TSinchSelectMenuOptionElement> & {
+    /** Value */
+    value: string;
+    /** Display text */
+    text: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Label that is used for a11y */
+    'aria-label': string;
+};

package/lib/esm/skeleton/index.d.ts

@@ -0,0 +1,11 @@
+import type { TSinchSkeletonElement, TSinchSkeletonReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-skeleton': TSinchSkeletonReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-skeleton': TSinchSkeletonElement;
+    }
+}

package/lib/esm/skeleton/types.d.ts

@@ -0,0 +1,9 @@
+import type { TSinchElementReact } from '../types';
+export type TSinchSkeletonElement = HTMLElement & {
+    /** Card like container */
+    setAttribute(name: 'card', value: ''): void;
+};
+export type TSinchSkeletonReact = TSinchElementReact<TSinchSkeletonElement> & {
+    /** Card like container */
+    card?: boolean;
+};

package/lib/esm/skeleton-item/index.d.ts

@@ -0,0 +1,11 @@
+import type { TSinchSkeletonItemElement, TSinchSkeletonItemReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-skeleton-item': TSinchSkeletonItemReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-skeleton-item': TSinchSkeletonItemElement;
+    }
+}

package/lib/esm/skeleton-item/types.d.ts

@@ -0,0 +1,13 @@
+import type { TRect, TSinchElementReact } from '../types';
+import type { TSinchSizeEx } from '../utils/size';
+export type TSinchSkeletonItemBoundingBox = TRect & {
+    radius: number;
+};
+export type TSinchSkeletonItemElement = HTMLElement & {
+    /** Size */
+    setAttribute(name: 'size', value: TSinchSizeEx): void;
+};
+export type TSinchSkeletonItemReact = TSinchElementReact<TSinchSkeletonItemElement> & {
+    /** Size */
+    size?: TSinchSizeEx;
+};

package/lib/esm/spinner/index.d.ts

@@ -0,0 +1,11 @@
+import type { TSinchSpinnerElement, TSinchSpinnerReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-spinner': TSinchSpinnerReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-spinner': TSinchSpinnerElement;
+    }
+}

package/lib/esm/spinner/types.d.ts

@@ -0,0 +1,12 @@
+import type { TSinchElementReact } from '../types';
+import type { TSinchSize } from '../utils/size';
+export type TSinchSpinnerElement = HTMLElement & {
+    /** Spinner size */
+    size: TSinchSize;
+    /** Spinner size */
+    setAttribute(name: 'size', value: TSinchSize): void;
+};
+export type TSinchSpinnerReact = TSinchElementReact<TSinchSpinnerElement> & {
+    /** Spinner size */
+    size?: TSinchSize;
+};

package/lib/esm/standalone.d.ts

@@ -0,0 +1,85 @@
+import './accordion-item/index.js';
+import './accordion/index.js';
+import './action-menu-option/index.js';
+import './action-menu/index.js';
+import './alert/index.js';
+import './avatar/index.js';
+import './badge/index.js';
+import './button/index.js';
+import './card-container/index.js';
+import './card/index.js';
+import './chat-block/index.js';
+import './chat-bubble/index.js';
+import './chat/index.js';
+import './checkbox/index.js';
+import './chip/index.js';
+import './code-tag/index.js';
+import './color-menu-option/index.js';
+import './color-menu/index.js';
+import './color-swatch/index.js';
+import './date-picker/index.js';
+import './dialog/index.js';
+import './emoji-picker/index.js';
+import './emoji/index.js';
+import './field/index.js';
+import './file-drop/index.js';
+import './file-picker/index.js';
+import './file-status/index.js';
+import './flag/index.js';
+import './grid-item/index.js';
+import './grid/index.js';
+import './help-tooltip/index.js';
+import './horizontal-stepper-item/index.js';
+import './horizontal-stepper/index.js';
+import './icon-button/index.js';
+import './icon/index.js';
+import './inline-alert/index.js';
+import './input/index.js';
+import './link/index.js';
+import './list-item/index.js';
+import './list/index.js';
+import './pagination/index.js';
+import './pop/index.js';
+import './popover/index.js';
+import './progress-stepper-item/index.js';
+import './progress-stepper/index.js';
+import './progress/index.js';
+import './radio-option/index.js';
+import './radio/index.js';
+import './rich-text/index.js';
+import './rich-textarea/index.js';
+import './segment-collapse/index.js';
+import './segment/index.js';
+import './segmented-control-option/index.js';
+import './segmented-control/index.js';
+import './segmented-icon-control-option/index.js';
+import './segmented-icon-control/index.js';
+import './select-button/index.js';
+import './select-menu-option/index.js';
+import './select-menu/index.js';
+import './skeleton-item/index.js';
+import './skeleton/index.js';
+import './spinner/index.js';
+import './stop-events/index.js';
+import './table-body/index.js';
+import './table-cell/index.js';
+import './table-head-cell/index.js';
+import './table-head/index.js';
+import './table-row/index.js';
+import './table/index.js';
+import './tabs-icon-option/index.js';
+import './tabs-option/index.js';
+import './tabs/index.js';
+import './tag/index.js';
+import './text/index.js';
+import './textarea/index.js';
+import './tile-control-option/index.js';
+import './tile-control/index.js';
+import './time-picker/index.js';
+import './title/index.js';
+import './toast-manager/index.js';
+import './toast/index.js';
+import './toggle/index.js';
+import './tooltip/index.js';
+import './vertical-stepper-item/index.js';
+import './vertical-stepper/index.js';

package/lib/esm/stop-events/index.d.ts

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

package/lib/esm/table/index.d.ts

@@ -0,0 +1,11 @@
+import type { TSinchTableElement, TSinchTableReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-table': TSinchTableReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-table': TSinchTableElement;
+    }
+}

package/lib/esm/table/types.d.ts

@@ -0,0 +1,3 @@
+import type { TSinchElementReact } from '../types';
+export type TSinchTableElement = HTMLElement;
+export type TSinchTableReact = TSinchElementReact<TSinchTableElement>;

package/lib/esm/table-body/index.d.ts

@@ -0,0 +1,11 @@
+import type { TSinchTableBodyElement, TSinchTableBodyReact } from './types';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sinch-table-body': TSinchTableBodyReact;
+        }
+    }
+    interface HTMLElementTagNameMap {
+        'sinch-table-body': TSinchTableBodyElement;
+    }
+}

package/lib/esm/table-body/types.d.ts

@@ -0,0 +1,3 @@
+import type { TSinchElementReact } from '../types';
+export type TSinchTableBodyElement = HTMLElement;
+export type TSinchTableBodyReact = TSinchElementReact<TSinchTableBodyElement>;