mcp/carbon-components-svelte
1
0
Fork 0
mirror of https://github.com/carbon-design-system/carbon-components-svelte.git synced 2025-09-14 18:01:06 +00:00
Code Issues Projects Releases Packages Wiki Activity

feat(types): use the SvelteComponentTyped interface in the TypeScript definitions (#515)

Browse source
This commit is contained in:
Eric Liu 2021-02-07 11:25:20 -08:00 • committed by GitHub
commit bcd28de86e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
161 changed files with 6379 additions and 6362 deletions
Download patch file Download diff file Expand all files Collapse all files

23
types/Accordion/Accordion.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { AccordionSkeletonProps } from "./AccordionSkeleton";
export interface AccordionProps extends AccordionSkeletonProps {
@ -26,15 +27,13 @@ export interface AccordionProps extends AccordionSkeletonProps {
skeleton?: boolean;
}
export default class Accordion {
$$prop_def: AccordionProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Accordion extends SvelteComponentTyped<
AccordionProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

31
types/Accordion/AccordionItem.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface AccordionItemProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["li"]> {
export interface AccordionItemProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["li"]> {
/**
* Specify the title of the accordion item heading
* Alternatively, use the "title" slot (e.g., <div slot="title">...</div>)
@ -27,18 +29,15 @@ export interface AccordionItemProps extends svelte.JSX.HTMLAttributes<HTMLElemen
iconDescription?: string;
}
export default class AccordionItem {
$$prop_def: AccordionItemProps;
$$slot_def: {
default: {};
title: {};
};
$on(eventname: "animationend", cb: (event: WindowEventMap["animationend"]) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class AccordionItem extends SvelteComponentTyped<
AccordionItemProps,
{
animationend: WindowEventMap["animationend"];
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
keydown: WindowEventMap["keydown"];
},
{ default: {}; title: {} }
> {}

24
types/Accordion/AccordionSkeleton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface AccordionSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["ul"]> {
export interface AccordionSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["ul"]> {
/**
* Specify the number of accordion items to render
* @default 4
@ -25,13 +27,13 @@ export interface AccordionSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLEl
open?: boolean;
}
export default class AccordionSkeleton {
$$prop_def: AccordionSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class AccordionSkeleton extends SvelteComponentTyped<
AccordionSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

17
types/AspectRatio/AspectRatio.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface AspectRatioProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface AspectRatioProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the aspect ratio
* @default "2x1"
@ -8,11 +10,8 @@ export interface AspectRatioProps extends svelte.JSX.HTMLAttributes<HTMLElementT
ratio?: "2x1" | "16x9" | "4x3" | "1x1" | "3x4" | "9x16" | "1x2";
}
export default class AspectRatio {
$$prop_def: AspectRatioProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class AspectRatio extends SvelteComponentTyped<
AspectRatioProps,
{},
{ default: {} }
> {}

23
types/Breadcrumb/Breadcrumb.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { BreadcrumbSkeletonProps } from "./BreadcrumbSkeleton";
export interface BreadcrumbProps extends BreadcrumbSkeletonProps {
@ -15,15 +16,13 @@ export interface BreadcrumbProps extends BreadcrumbSkeletonProps {
skeleton?: boolean;
}
export default class Breadcrumb {
$$prop_def: BreadcrumbProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Breadcrumb extends SvelteComponentTyped<
BreadcrumbProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

26
types/Breadcrumb/BreadcrumbItem.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface BreadcrumbItemProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["li"]> {
export interface BreadcrumbItemProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["li"]> {
/**
* Set the `href` to use an anchor link
*/
@ -13,15 +15,13 @@ export interface BreadcrumbItemProps extends svelte.JSX.HTMLAttributes<HTMLEleme
isCurrentPage?: boolean;
}
export default class BreadcrumbItem {
$$prop_def: BreadcrumbItemProps;
$$slot_def: {
default: { props?: { ["aria-current"]?: string; class: "bx--link" } };
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class BreadcrumbItem extends SvelteComponentTyped<
BreadcrumbItemProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: { props?: { ["aria-current"]?: string; class: "bx--link" } } }
> {}

24
types/Breadcrumb/BreadcrumbSkeleton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface BreadcrumbSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface BreadcrumbSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to hide the breadcrumb trailing slash
* @default false
@ -14,13 +16,13 @@ export interface BreadcrumbSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLE
count?: number;
}
export default class BreadcrumbSkeleton {
$$prop_def: BreadcrumbSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class BreadcrumbSkeleton extends SvelteComponentTyped<
BreadcrumbSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

32
types/Button/Button.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { ButtonSkeletonProps } from "./ButtonSkeleton";
export interface ButtonProps
@ -10,7 +11,14 @@ export interface ButtonProps
* Specify the kind of button
* @default "primary"
*/
kind?: "primary" | "secondary" | "tertiary" | "ghost" | "danger" | "danger-tertiary" | "danger-ghost";
kind?:
| "primary"
| "secondary"
| "tertiary"
| "ghost"
| "danger"
| "danger-tertiary"
| "danger-ghost";
/**
* Specify the size of button
@ -90,9 +98,15 @@ export interface ButtonProps
ref?: null | HTMLAnchorElement | HTMLButtonElement;
}
export default class Button {
$$prop_def: ButtonProps;
$$slot_def: {
export default class Button extends SvelteComponentTyped<
ButtonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{
default: {
props: {
role: "button";
@ -104,11 +118,5 @@ export default class Button {
[key: string]: any;
};
};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
}
> {}

17
types/Button/ButtonSet.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ButtonSetProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ButtonSetProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to stack the buttons vertically
* @default false
@ -8,11 +10,8 @@ export interface ButtonSetProps extends svelte.JSX.HTMLAttributes<HTMLElementTag
stacked?: boolean;
}
export default class ButtonSet {
$$prop_def: ButtonSetProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ButtonSet extends SvelteComponentTyped<
ButtonSetProps,
{},
{ default: {} }
> {}

24
types/Button/ButtonSkeleton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ButtonSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["a"]> {
export interface ButtonSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["a"]> {
/**
* Set the `href` to use an anchor link
*/
@ -18,13 +20,13 @@ export interface ButtonSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLEleme
small?: boolean;
}
export default class ButtonSkeleton {
$$prop_def: ButtonSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ButtonSkeleton extends SvelteComponentTyped<
ButtonSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

25
types/Checkbox/Checkbox.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface CheckboxProps {
/**
@ -67,15 +68,15 @@ export interface CheckboxProps {
ref?: null | HTMLInputElement;
}
export default class Checkbox {
$$prop_def: CheckboxProps;
$$slot_def: {};
$on(eventname: "check", cb: (event: CustomEvent<boolean>) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "change", cb: (event: WindowEventMap["change"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Checkbox extends SvelteComponentTyped<
CheckboxProps,
{
check: CustomEvent<boolean>;
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
change: WindowEventMap["change"];
},
{}
> {}

24
types/Checkbox/CheckboxSkeleton.d.ts vendored
View file

@ -1,14 +1,16 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface CheckboxSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export interface CheckboxSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export default class CheckboxSkeleton {
$$prop_def: CheckboxSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class CheckboxSkeleton extends SvelteComponentTyped<
CheckboxSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

25
types/CodeSnippet/CodeSnippet.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface CodeSnippetProps {
/**
@ -106,16 +107,14 @@ export interface CodeSnippetProps {
ref?: null | HTMLPreElement;
}
export default class CodeSnippet {
$$prop_def: CodeSnippetProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "animationend", cb: (event: WindowEventMap["animationend"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class CodeSnippet extends SvelteComponentTyped<
CodeSnippetProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
animationend: WindowEventMap["animationend"];
},
{ default: {} }
> {}

24
types/CodeSnippet/CodeSnippetSkeleton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface CodeSnippetSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface CodeSnippetSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the type of code snippet
* @default "single"
@ -8,13 +10,13 @@ export interface CodeSnippetSkeletonProps extends svelte.JSX.HTMLAttributes<HTML
type?: "single" | "multi";
}
export default class CodeSnippetSkeleton {
$$prop_def: CodeSnippetSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class CodeSnippetSkeleton extends SvelteComponentTyped<
CodeSnippetSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

35
types/ComboBox/ComboBox.d.ts vendored
View file

@ -1,11 +1,13 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ComboBoxItem {
id: string;
text: string;
}
export interface ComboBoxProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ComboBoxProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the combobox items
* @default []
@ -118,18 +120,19 @@ export interface ComboBoxProps extends svelte.JSX.HTMLAttributes<HTMLElementTagN
listRef?: null | HTMLDivElement;
}
export default class ComboBox {
$$prop_def: ComboBoxProps;
$$slot_def: {};
$on(
eventname: "select",
cb: (event: CustomEvent<{ selectedId: string; selectedIndex: number; selectedItem: ComboBoxItem }>) => void
): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: "focus", cb: (event: WindowEventMap["focus"]) => void): () => void;
$on(eventname: "blur", cb: (event: WindowEventMap["blur"]) => void): () => void;
$on(eventname: "clear", cb: (event: WindowEventMap["clear"]) => void): () => void;
$on(eventname: "scroll", cb: (event: WindowEventMap["scroll"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ComboBox extends SvelteComponentTyped<
ComboBoxProps,
{
select: CustomEvent<{
selectedId: string;
selectedIndex: number;
selectedItem: ComboBoxItem;
}>;
keydown: WindowEventMap["keydown"];
focus: WindowEventMap["focus"];
blur: WindowEventMap["blur"];
clear: WindowEventMap["clear"];
scroll: WindowEventMap["scroll"];
},
{}
> {}

34
types/ComposedModal/ComposedModal.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ComposedModalProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ComposedModalProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the size of the composed modal
*/
@ -43,19 +45,17 @@ export interface ComposedModalProps extends svelte.JSX.HTMLAttributes<HTMLElemen
ref?: null | HTMLDivElement;
}
export default class ComposedModal {
$$prop_def: ComposedModalProps;
$$slot_def: {
default: {};
};
$on(eventname: "transitionend", cb: (event: CustomEvent<{ open: boolean }>) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "submit", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: "close", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: "open", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ComposedModal extends SvelteComponentTyped<
ComposedModalProps,
{
transitionend: CustomEvent<{ open: boolean }>;
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
submit: CustomEvent<any>;
close: CustomEvent<any>;
open: CustomEvent<any>;
},
{ default: {} }
> {}

17
types/ComposedModal/ModalBody.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ModalBodyProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ModalBodyProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` if the modal contains form elements
* @default false
@ -14,11 +16,8 @@ export interface ModalBodyProps extends svelte.JSX.HTMLAttributes<HTMLElementTag
hasScrollingContent?: boolean;
}
export default class ModalBody {
$$prop_def: ModalBodyProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ModalBody extends SvelteComponentTyped<
ModalBodyProps,
{},
{ default: {} }
> {}

17
types/ComposedModal/ModalFooter.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ModalFooterProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ModalFooterProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the primary button text
* @default ""
@ -36,11 +38,8 @@ export interface ModalFooterProps extends svelte.JSX.HTMLAttributes<HTMLElementT
danger?: boolean;
}
export default class ModalFooter {
$$prop_def: ModalFooterProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ModalFooter extends SvelteComponentTyped<
ModalFooterProps,
{},
{ default: {} }
> {}

18
types/ComposedModal/ModalHeader.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ModalHeaderProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ModalHeaderProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the modal title
* @default ""
@ -44,12 +46,8 @@ export interface ModalHeaderProps extends svelte.JSX.HTMLAttributes<HTMLElementT
iconDescription?: string;
}
export default class ModalHeader {
$$prop_def: ModalHeaderProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ModalHeader extends SvelteComponentTyped<
ModalHeaderProps,
{ click: WindowEventMap["click"] },
{ default: {} }
> {}

28
types/ContentSwitcher/ContentSwitcher.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ContentSwitcherProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ContentSwitcherProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the selected index of the switch item
* @default 0
@ -19,16 +21,14 @@ export interface ContentSwitcherProps extends svelte.JSX.HTMLAttributes<HTMLElem
size?: "sm" | "xl";
}
export default class ContentSwitcher {
$$prop_def: ContentSwitcherProps;
$$slot_def: {
default: {};
};
$on(eventname: "change", cb: (event: CustomEvent<number>) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ContentSwitcher extends SvelteComponentTyped<
ContentSwitcherProps,
{
change: CustomEvent<number>;
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

28
types/ContentSwitcher/Switch.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface SwitchProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["button"]> {
export interface SwitchProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["button"]> {
/**
* Specify the switch text
* Alternatively, use the "text" slot (e.g., <span slot="text">...</span>)
@ -33,16 +35,14 @@ export interface SwitchProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNam
ref?: null | HTMLButtonElement;
}
export default class Switch {
$$prop_def: SwitchProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Switch extends SvelteComponentTyped<
SwitchProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
keydown: WindowEventMap["keydown"];
},
{ default: {} }
> {}

22
types/Copy/Copy.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface CopyProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["button"]> {
export interface CopyProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["button"]> {
/**
* Set the feedback text shown after clicking the button
* @default "Copied!"
@ -20,13 +22,11 @@ export interface CopyProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameM
ref?: null | HTMLButtonElement;
}
export default class Copy {
$$prop_def: CopyProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "animationend", cb: (event: WindowEventMap["animationend"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Copy extends SvelteComponentTyped<
CopyProps,
{
click: WindowEventMap["click"];
animationend: WindowEventMap["animationend"];
},
{ default: {} }
> {}

17
types/CopyButton/CopyButton.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { CopyProps } from "../Copy/Copy";
export interface CopyButtonProps extends CopyProps {
@ -9,11 +10,11 @@ export interface CopyButtonProps extends CopyProps {
iconDescription?: string;
}
export default class CopyButton {
$$prop_def: CopyButtonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "animationend", cb: (event: WindowEventMap["animationend"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class CopyButton extends SvelteComponentTyped<
CopyButtonProps,
{
click: WindowEventMap["click"];
animationend: WindowEventMap["animationend"];
},
{}
> {}

50
types/DataTable/DataTable.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export type DataTableKey = string;
@ -128,31 +129,32 @@ export interface DataTableProps {
stickyHeader?: boolean;
}
export default class DataTable {
$$prop_def: DataTableProps;
$$slot_def: {
export default class DataTable extends SvelteComponentTyped<
DataTableProps,
{
click: CustomEvent<{
header?: DataTableHeader;
row?: DataTableRow;
cell?: DataTableCell;
}>;
["click:header--expand"]: CustomEvent<{ expanded: boolean }>;
["click:header"]: CustomEvent<{
header: DataTableHeader;
sortDirection: "ascending" | "descending" | "none";
}>;
["click:row"]: CustomEvent<DataTableRow>;
["mouseenter:row"]: CustomEvent<DataTableRow>;
["mouseleave:row"]: CustomEvent<DataTableRow>;
["click:row--expand"]: CustomEvent<{
expanded: boolean;
row: DataTableRow;
}>;
["click:cell"]: CustomEvent<DataTableCell>;
},
{
default: {};
cell: { row: DataTableRow; cell: DataTableCell };
["cell-header"]: { header: DataTableNonEmptyHeader };
["expanded-row"]: { row: DataTableRow };
};
$on(
eventname: "click",
cb: (event: CustomEvent<{ header?: DataTableHeader; row?: DataTableRow; cell?: DataTableCell }>) => void
): () => void;
$on(eventname: "click:header--expand", cb: (event: CustomEvent<{ expanded: boolean }>) => void): () => void;
$on(
eventname: "click:header",
cb: (event: CustomEvent<{ header: DataTableHeader; sortDirection: "ascending" | "descending" | "none" }>) => void
): () => void;
$on(eventname: "click:row", cb: (event: CustomEvent<DataTableRow>) => void): () => void;
$on(eventname: "mouseenter:row", cb: (event: CustomEvent<DataTableRow>) => void): () => void;
$on(eventname: "mouseleave:row", cb: (event: CustomEvent<DataTableRow>) => void): () => void;
$on(
eventname: "click:row--expand",
cb: (event: CustomEvent<{ expanded: boolean; row: DataTableRow }>) => void
): () => void;
$on(eventname: "click:cell", cb: (event: CustomEvent<DataTableCell>) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
}
> {}

21
types/DataTable/DataTableSkeleton.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { DataTableHeader } from "../DataTable/DataTable";
export interface DataTableSkeletonProps
@ -48,13 +49,13 @@ export interface DataTableSkeletonProps
showToolbar?: boolean;
}
export default class DataTableSkeleton {
$$prop_def: DataTableSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class DataTableSkeleton extends SvelteComponentTyped<
DataTableSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

17
types/DataTable/Table.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface TableProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["section"]> {
export interface TableProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["section"]> {
/**
* Set the size of the table
*/
@ -37,11 +39,8 @@ export interface TableProps extends svelte.JSX.HTMLAttributes<HTMLElementTagName
stickyHeader?: boolean;
}
export default class Table {
$$prop_def: TableProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Table extends SvelteComponentTyped<
TableProps,
{},
{ default: {} }
> {}

17
types/DataTable/TableBody.d.ts vendored
View file

@ -1,12 +1,11 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface TableBodyProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["tbody"]> {}
export interface TableBodyProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["tbody"]> {}
export default class TableBody {
$$prop_def: TableBodyProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class TableBody extends SvelteComponentTyped<
TableBodyProps,
{},
{ default: {} }
> {}

26
types/DataTable/TableCell.d.ts vendored
View file

@ -1,16 +1,16 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface TableCellProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["td"]> {}
export interface TableCellProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["td"]> {}
export default class TableCell {
$$prop_def: TableCellProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class TableCell extends SvelteComponentTyped<
TableCellProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

17
types/DataTable/TableContainer.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface TableContainerProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface TableContainerProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the title of the data table
* @default ""
@ -20,11 +22,8 @@ export interface TableContainerProps extends svelte.JSX.HTMLAttributes<HTMLEleme
stickyHeader?: boolean;
}
export default class TableContainer {
$$prop_def: TableContainerProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class TableContainer extends SvelteComponentTyped<
TableContainerProps,
{},
{ default: {} }
> {}

26
types/DataTable/TableHead.d.ts vendored
View file

@ -1,16 +1,16 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface TableHeadProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["thead"]> {}
export interface TableHeadProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["thead"]> {}
export default class TableHead {
$$prop_def: TableHeadProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class TableHead extends SvelteComponentTyped<
TableHeadProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

26
types/DataTable/TableHeader.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface TableHeaderProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["th"]> {
export interface TableHeaderProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["th"]> {
/**
* Specify the `scope` attribute
* @default "col"
@ -20,15 +22,13 @@ export interface TableHeaderProps extends svelte.JSX.HTMLAttributes<HTMLElementT
id?: string;
}
export default class TableHeader {
$$prop_def: TableHeaderProps;
$$slot_def: {
default: {};
};
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class TableHeader extends SvelteComponentTyped<
TableHeaderProps,
{
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
click: WindowEventMap["click"];
},
{ default: {} }
> {}

26
types/DataTable/TableRow.d.ts vendored
View file

@ -1,16 +1,16 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface TableRowProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["tr"]> {}
export interface TableRowProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["tr"]> {}
export default class TableRow {
$$prop_def: TableRowProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class TableRow extends SvelteComponentTyped<
TableRowProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

17
types/DataTable/Toolbar.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ToolbarProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["section"]> {
export interface ToolbarProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["section"]> {
/**
* Specify the toolbar size
* @default "default"
@ -8,11 +10,8 @@ export interface ToolbarProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNa
size?: "sm" | "default";
}
export default class Toolbar {
$$prop_def: ToolbarProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Toolbar extends SvelteComponentTyped<
ToolbarProps,
{},
{ default: {} }
> {}

17
types/DataTable/ToolbarBatchActions.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ToolbarBatchActionsProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ToolbarBatchActionsProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Override the total items selected text
* @default (totalSelected) => `${totalSelected} item${totalSelected === 1 ? "" : "s"} selected`
@ -8,11 +10,8 @@ export interface ToolbarBatchActionsProps extends svelte.JSX.HTMLAttributes<HTML
formatTotalSelected?: (totalSelected: number) => string;
}
export default class ToolbarBatchActions {
$$prop_def: ToolbarBatchActionsProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ToolbarBatchActions extends SvelteComponentTyped<
ToolbarBatchActionsProps,
{},
{ default: {} }
> {}

14
types/DataTable/ToolbarContent.d.ts vendored
View file

@ -1,12 +1,10 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ToolbarContentProps {}
export default class ToolbarContent {
$$prop_def: ToolbarContentProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ToolbarContent extends SvelteComponentTyped<
ToolbarContentProps,
{},
{ default: {} }
> {}

14
types/DataTable/ToolbarMenu.d.ts vendored
View file

@ -1,13 +1,11 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { OverflowMenuProps } from "../OverflowMenu/OverflowMenu";
export interface ToolbarMenuProps extends OverflowMenuProps {}
export default class ToolbarMenu {
$$prop_def: ToolbarMenuProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ToolbarMenu extends SvelteComponentTyped<
ToolbarMenuProps,
{},
{ default: {} }
> {}

16
types/DataTable/ToolbarMenuItem.d.ts vendored
View file

@ -1,15 +1,11 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { OverflowMenuItemProps } from "../OverflowMenu/OverflowMenuItem";
export interface ToolbarMenuItemProps extends OverflowMenuItemProps {}
export default class ToolbarMenuItem {
$$prop_def: ToolbarMenuItemProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ToolbarMenuItem extends SvelteComponentTyped<
ToolbarMenuItemProps,
{ click: WindowEventMap["click"]; keydown: WindowEventMap["keydown"] },
{ default: {} }
> {}

21
types/DataTable/ToolbarSearch.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ToolbarSearchProps {
/**
@ -38,13 +39,13 @@ export interface ToolbarSearchProps {
ref?: null | HTMLInputElement;
}
export default class ToolbarSearch {
$$prop_def: ToolbarSearchProps;
$$slot_def: {};
$on(eventname: "change", cb: (event: WindowEventMap["change"]) => void): () => void;
$on(eventname: "input", cb: (event: WindowEventMap["input"]) => void): () => void;
$on(eventname: "focus", cb: (event: WindowEventMap["focus"]) => void): () => void;
$on(eventname: "blur", cb: (event: WindowEventMap["blur"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ToolbarSearch extends SvelteComponentTyped<
ToolbarSearchProps,
{
change: WindowEventMap["change"];
input: WindowEventMap["input"];
focus: WindowEventMap["focus"];
blur: WindowEventMap["blur"];
},
{}
> {}

28
types/DatePicker/DatePicker.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface DatePickerProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface DatePickerProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the date picker type
* @default "simple"
@ -61,16 +63,14 @@ export interface DatePickerProps extends svelte.JSX.HTMLAttributes<HTMLElementTa
id?: string;
}
export default class DatePicker {
$$prop_def: DatePickerProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "change", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class DatePicker extends SvelteComponentTyped<
DatePickerProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
change: CustomEvent<any>;
},
{ default: {} }
> {}

22
types/DatePicker/DatePickerInput.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface DatePickerInputProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface DatePickerInputProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the size of the input
*/
@ -90,12 +92,12 @@ export interface DatePickerInputProps extends svelte.JSX.HTMLAttributes<HTMLElem
ref?: null | HTMLInputElement;
}
export default class DatePickerInput {
$$prop_def: DatePickerInputProps;
$$slot_def: {};
$on(eventname: "input", cb: (event: WindowEventMap["input"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: "blur", cb: (event: WindowEventMap["blur"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class DatePickerInput extends SvelteComponentTyped<
DatePickerInputProps,
{
input: WindowEventMap["input"];
keydown: WindowEventMap["keydown"];
blur: WindowEventMap["blur"];
},
{}
> {}

24
types/DatePicker/DatePickerSkeleton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface DatePickerSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface DatePickerSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to use the range variant
* @default false
@ -14,13 +16,13 @@ export interface DatePickerSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLE
id?: string;
}
export default class DatePickerSkeleton {
$$prop_def: DatePickerSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class DatePickerSkeleton extends SvelteComponentTyped<
DatePickerSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

25
types/Dropdown/Dropdown.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export type DropdownItemId = string;
@ -9,7 +10,8 @@ export interface DropdownItem {
text: DropdownItemText;
}
export interface DropdownProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface DropdownProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the dropdown items
* @default []
@ -133,13 +135,14 @@ export interface DropdownProps extends svelte.JSX.HTMLAttributes<HTMLElementTagN
ref?: null | HTMLButtonElement;
}
export default class Dropdown {
$$prop_def: DropdownProps;
$$slot_def: {};
$on(
eventname: "select",
cb: (event: CustomEvent<{ selectedId: DropdownItemId; selectedIndex: number; selectedItem: DropdownItem }>) => void
): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Dropdown extends SvelteComponentTyped<
DropdownProps,
{
select: CustomEvent<{
selectedId: DropdownItemId;
selectedIndex: number;
selectedItem: DropdownItem;
}>;
},
{}
> {}

24
types/Dropdown/DropdownSkeleton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface DropdownSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface DropdownSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to use the inline variant
* @default false
@ -8,13 +10,13 @@ export interface DropdownSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLEle
inline?: boolean;
}
export default class DropdownSkeleton {
$$prop_def: DropdownSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class DropdownSkeleton extends SvelteComponentTyped<
DropdownSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

32
types/FileUploader/FileUploader.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FileUploaderProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface FileUploaderProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the file uploader status
* @default "uploading"
@ -69,17 +71,17 @@ export interface FileUploaderProps extends svelte.JSX.HTMLAttributes<HTMLElement
name?: string;
}
export default class FileUploader {
$$prop_def: FileUploaderProps;
$$slot_def: {};
$on(eventname: "add", cb: (event: CustomEvent<File[]>) => void): () => void;
$on(eventname: "remove", cb: (event: CustomEvent<File[]>) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "change", cb: (event: WindowEventMap["change"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class FileUploader extends SvelteComponentTyped<
FileUploaderProps,
{
add: CustomEvent<File[]>;
remove: CustomEvent<File[]>;
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
change: WindowEventMap["change"];
keydown: WindowEventMap["keydown"];
},
{}
> {}

22
types/FileUploader/FileUploaderButton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FileUploaderButtonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["input"]> {
export interface FileUploaderButtonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["input"]> {
/**
* Specify the accepted file types
* @default []
@ -68,12 +70,12 @@ export interface FileUploaderButtonProps extends svelte.JSX.HTMLAttributes<HTMLE
ref?: null | HTMLInputElement;
}
export default class FileUploaderButton {
$$prop_def: FileUploaderButtonProps;
$$slot_def: {};
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: "change", cb: (event: WindowEventMap["change"]) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class FileUploaderButton extends SvelteComponentTyped<
FileUploaderButtonProps,
{
keydown: WindowEventMap["keydown"];
change: WindowEventMap["change"];
click: WindowEventMap["click"];
},
{}
> {}

30
types/FileUploader/FileUploaderDropContainer.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FileUploaderDropContainerProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface FileUploaderDropContainerProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the accepted file types
* @default []
@ -63,16 +65,16 @@ export interface FileUploaderDropContainerProps extends svelte.JSX.HTMLAttribute
ref?: null | HTMLInputElement;
}
export default class FileUploaderDropContainer {
$$prop_def: FileUploaderDropContainerProps;
$$slot_def: {};
$on(eventname: "add", cb: (event: CustomEvent<FileList>) => void): () => void;
$on(eventname: "dragover", cb: (event: WindowEventMap["dragover"]) => void): () => void;
$on(eventname: "dragleave", cb: (event: WindowEventMap["dragleave"]) => void): () => void;
$on(eventname: "drop", cb: (event: WindowEventMap["drop"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: "change", cb: (event: WindowEventMap["change"]) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class FileUploaderDropContainer extends SvelteComponentTyped<
FileUploaderDropContainerProps,
{
add: CustomEvent<FileList>;
dragover: WindowEventMap["dragover"];
dragleave: WindowEventMap["dragleave"];
drop: WindowEventMap["drop"];
keydown: WindowEventMap["keydown"];
change: WindowEventMap["change"];
click: WindowEventMap["click"];
},
{}
> {}

24
types/FileUploader/FileUploaderItem.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FileUploaderItemProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["span"]> {
export interface FileUploaderItemProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["span"]> {
/**
* Specify the file uploader status
* @default "uploading"
@ -44,13 +46,13 @@ export interface FileUploaderItemProps extends svelte.JSX.HTMLAttributes<HTMLEle
name?: string;
}
export default class FileUploaderItem {
$$prop_def: FileUploaderItemProps;
$$slot_def: {};
$on(eventname: "delete", cb: (event: CustomEvent<string>) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class FileUploaderItem extends SvelteComponentTyped<
FileUploaderItemProps,
{
delete: CustomEvent<string>;
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

24
types/FileUploader/FileUploaderSkeleton.d.ts vendored
View file

@ -1,14 +1,16 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FileUploaderSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export interface FileUploaderSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export default class FileUploaderSkeleton {
$$prop_def: FileUploaderSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class FileUploaderSkeleton extends SvelteComponentTyped<
FileUploaderSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

14
types/FileUploader/Filename.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FilenameProps {
/**
@ -20,11 +21,8 @@ export interface FilenameProps {
invalid?: boolean;
}
export default class Filename {
$$prop_def: FilenameProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Filename extends SvelteComponentTyped<
FilenameProps,
{ click: WindowEventMap["click"]; keydown: WindowEventMap["keydown"] },
{}
> {}

15
types/FluidForm/FluidForm.d.ts vendored
View file

@ -1,13 +1,10 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FluidFormProps {}
export default class FluidForm {
$$prop_def: FluidFormProps;
$$slot_def: {
default: {};
};
$on(eventname: "submit", cb: (event: WindowEventMap["submit"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class FluidForm extends SvelteComponentTyped<
FluidFormProps,
{ submit: WindowEventMap["submit"] },
{ default: {} }
> {}

28
types/Form/Form.d.ts vendored
View file

@ -1,17 +1,17 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FormProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["form"]> {}
export interface FormProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["form"]> {}
export default class Form {
$$prop_def: FormProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "submit", cb: (event: WindowEventMap["submit"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Form extends SvelteComponentTyped<
FormProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
submit: WindowEventMap["submit"];
},
{ default: {} }
> {}

26
types/FormGroup/FormGroup.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FormGroupProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["fieldset"]> {
export interface FormGroupProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["fieldset"]> {
/**
* Set to `true` to indicate an invalid state
* @default false
@ -26,15 +28,13 @@ export interface FormGroupProps extends svelte.JSX.HTMLAttributes<HTMLElementTag
legendText?: string;
}
export default class FormGroup {
$$prop_def: FormGroupProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class FormGroup extends SvelteComponentTyped<
FormGroupProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

26
types/FormItem/FormItem.d.ts vendored
View file

@ -1,16 +1,16 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FormItemProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export interface FormItemProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export default class FormItem {
$$prop_def: FormItemProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class FormItem extends SvelteComponentTyped<
FormItemProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

26
types/FormLabel/FormLabel.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FormLabelProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["label"]> {
export interface FormLabelProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["label"]> {
/**
* Set an id to be used by the label element
* @default "ccs-" + Math.random().toString(36)
@ -8,15 +10,13 @@ export interface FormLabelProps extends svelte.JSX.HTMLAttributes<HTMLElementTag
id?: string;
}
export default class FormLabel {
$$prop_def: FormLabelProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class FormLabel extends SvelteComponentTyped<
FormLabelProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

17
types/Grid/Column.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export type ColumnSize = boolean | number;
@ -9,7 +10,8 @@ export interface ColumnSizeDescriptor {
export type ColumnBreakpoint = ColumnSize | ColumnSizeDescriptor;
export interface ColumnProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ColumnProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to render a custom HTML element
* Props are destructured as `props` in the default slot (e.g., <Column let:props><article {...props}>...</article></Column>)
@ -72,11 +74,8 @@ export interface ColumnProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNam
max?: ColumnBreakpoint;
}
export default class Column {
$$prop_def: ColumnProps;
$$slot_def: {
default: { props: { class: string; [key: string]: any } };
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Column extends SvelteComponentTyped<
ColumnProps,
{},
{ default: { props: { class: string; [key: string]: any } } }
> {}

17
types/Grid/Grid.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface GridProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface GridProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to render a custom HTML element
* Props are destructured as `props` in the default slot (e.g., <Grid let:props><header {...props}>...</header></Grid>)
@ -51,11 +53,8 @@ export interface GridProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameM
padding?: boolean;
}
export default class Grid {
$$prop_def: GridProps;
$$slot_def: {
default: { props: { class: string; [key: string]: any } };
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Grid extends SvelteComponentTyped<
GridProps,
{},
{ default: { props: { class: string; [key: string]: any } } }
> {}

17
types/Grid/Row.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface RowProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface RowProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to render a custom HTML element
* Props are destructured as `props` in the default slot (e.g., <Row let:props><section {...props}>...</section></Row>)
@ -45,11 +47,8 @@ export interface RowProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMa
padding?: boolean;
}
export default class Row {
$$prop_def: RowProps;
$$slot_def: {
default: { props: { class: string; [key: string]: any } };
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Row extends SvelteComponentTyped<
RowProps,
{},
{ default: { props: { class: string; [key: string]: any } } }
> {}

25
types/Icon/Icon.d.ts vendored
View file

@ -1,7 +1,10 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { IconSkeletonProps } from "./IconSkeleton";
export interface IconProps extends IconSkeletonProps, svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["svg"]> {
export interface IconProps
extends IconSkeletonProps,
svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["svg"]> {
/**
* Specify the icon from `carbon-icons-svelte` to render
*/
@ -14,13 +17,13 @@ export interface IconProps extends IconSkeletonProps, svelte.JSX.HTMLAttributes<
skeleton?: boolean;
}
export default class Icon {
$$prop_def: IconProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Icon extends SvelteComponentTyped<
IconProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

24
types/Icon/IconSkeleton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface IconSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface IconSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the size of the icon
* @default 16
@ -8,13 +10,13 @@ export interface IconSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElement
size?: number;
}
export default class IconSkeleton {
$$prop_def: IconSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class IconSkeleton extends SvelteComponentTyped<
IconSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

26
types/InlineLoading/InlineLoading.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface InlineLoadingProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface InlineLoadingProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the loading status
* @default "active"
@ -24,14 +26,14 @@ export interface InlineLoadingProps extends svelte.JSX.HTMLAttributes<HTMLElemen
successDelay?: number;
}
export default class InlineLoading {
$$prop_def: InlineLoadingProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "success", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class InlineLoading extends SvelteComponentTyped<
InlineLoadingProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
success: CustomEvent<any>;
},
{}
> {}

26
types/Link/Link.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface LinkProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["p"]> {
export interface LinkProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["p"]> {
/**
* Specify the size of the link
*/
@ -36,15 +38,13 @@ export interface LinkProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameM
ref?: null | HTMLAnchorElement | HTMLParagraphElement;
}
export default class Link {
$$prop_def: LinkProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Link extends SvelteComponentTyped<
LinkProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

23
types/Link/OutboundLink.d.ts vendored
View file

@ -1,17 +1,16 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { LinkProps } from "./Link";
export interface OutboundLinkProps extends LinkProps {}
export default class OutboundLink {
$$prop_def: OutboundLinkProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class OutboundLink extends SvelteComponentTyped<
OutboundLinkProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

19
types/ListBox/ListBox.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ListBoxProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ListBoxProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the size of the list box
*/
@ -55,13 +57,8 @@ export interface ListBoxProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNa
warnText?: string;
}
export default class ListBox {
$$prop_def: ListBoxProps;
$$slot_def: {
default: {};
};
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ListBox extends SvelteComponentTyped<
ListBoxProps,
{ keydown: WindowEventMap["keydown"]; click: WindowEventMap["click"] },
{ default: {} }
> {}

30
types/ListBox/ListBoxField.d.ts vendored
View file

@ -1,8 +1,10 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export type ListBoxFieldTranslationId = "close" | "open";
export interface ListBoxFieldProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ListBoxFieldProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to disable the list box field
* @default false
@ -47,17 +49,15 @@ export interface ListBoxFieldProps extends svelte.JSX.HTMLAttributes<HTMLElement
ref?: null | HTMLDivElement;
}
export default class ListBoxField {
$$prop_def: ListBoxFieldProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: "blur", cb: (event: WindowEventMap["blur"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ListBoxField extends SvelteComponentTyped<
ListBoxFieldProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
keydown: WindowEventMap["keydown"];
blur: WindowEventMap["blur"];
},
{ default: {} }
> {}

18
types/ListBox/ListBoxMenu.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ListBoxMenuProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ListBoxMenuProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set an id for the top-level element
* @default "ccs-" + Math.random().toString(36)
@ -14,12 +16,8 @@ export interface ListBoxMenuProps extends svelte.JSX.HTMLAttributes<HTMLElementT
ref?: null | HTMLDivElement;
}
export default class ListBoxMenu {
$$prop_def: ListBoxMenuProps;
$$slot_def: {
default: {};
};
$on(eventname: "scroll", cb: (event: WindowEventMap["scroll"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ListBoxMenu extends SvelteComponentTyped<
ListBoxMenuProps,
{ scroll: WindowEventMap["scroll"] },
{ default: {} }
> {}

16
types/ListBox/ListBoxMenuIcon.d.ts vendored
View file

@ -1,8 +1,10 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export type ListBoxMenuIconTranslationId = "close" | "open";
export interface ListBoxMenuIconProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ListBoxMenuIconProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to open the list box menu icon
* @default false
@ -23,10 +25,8 @@ export interface ListBoxMenuIconProps extends svelte.JSX.HTMLAttributes<HTMLElem
translateWithId?: (id: ListBoxMenuIconTranslationId) => string;
}
export default class ListBoxMenuIcon {
$$prop_def: ListBoxMenuIconProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ListBoxMenuIcon extends SvelteComponentTyped<
ListBoxMenuIconProps,
{ click: WindowEventMap["click"] },
{}
> {}

24
types/ListBox/ListBoxMenuItem.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ListBoxMenuItemProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ListBoxMenuItemProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to enable the active state
* @default false
@ -14,14 +16,12 @@ export interface ListBoxMenuItemProps extends svelte.JSX.HTMLAttributes<HTMLElem
highlighted?: boolean;
}
export default class ListBoxMenuItem {
$$prop_def: ListBoxMenuItemProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ListBoxMenuItem extends SvelteComponentTyped<
ListBoxMenuItemProps,
{
click: WindowEventMap["click"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

16
types/ListBox/ListBoxSelection.d.ts vendored
View file

@ -1,8 +1,10 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export type ListBoxSelectionTranslationId = "clearAll" | "clearSelection";
export interface ListBoxSelectionProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ListBoxSelectionProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the number of selected items
*/
@ -34,10 +36,8 @@ export interface ListBoxSelectionProps extends svelte.JSX.HTMLAttributes<HTMLEle
ref?: null | HTMLDivElement;
}
export default class ListBoxSelection {
$$prop_def: ListBoxSelectionProps;
$$slot_def: {};
$on(eventname: "clear", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ListBoxSelection extends SvelteComponentTyped<
ListBoxSelectionProps,
{ clear: CustomEvent<any> },
{}
> {}

26
types/ListItem/ListItem.d.ts vendored
View file

@ -1,16 +1,16 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ListItemProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["li"]> {}
export interface ListItemProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["li"]> {}
export default class ListItem {
$$prop_def: ListItemProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ListItem extends SvelteComponentTyped<
ListItemProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

15
types/Loading/Loading.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface LoadingProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface LoadingProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to use the small variant
* @default false
@ -32,9 +34,8 @@ export interface LoadingProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNa
id?: string;
}
export default class Loading {
$$prop_def: LoadingProps;
$$slot_def: {};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Loading extends SvelteComponentTyped<
LoadingProps,
{},
{}
> {}

40
types/Modal/Modal.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ModalProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ModalProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the size of the modal
*/
@ -112,23 +114,19 @@ export interface ModalProps extends svelte.JSX.HTMLAttributes<HTMLElementTagName
ref?: null | HTMLDivElement;
}
export default class Modal {
$$prop_def: ModalProps;
$$slot_def: {
default: {};
heading: {};
label: {};
};
$on(eventname: "transitionend", cb: (event: CustomEvent<{ open: boolean }>) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "submit", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: "click:button--secondary", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: "close", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: "open", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Modal extends SvelteComponentTyped<
ModalProps,
{
transitionend: CustomEvent<{ open: boolean }>;
keydown: WindowEventMap["keydown"];
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
submit: CustomEvent<any>;
["click:button--secondary"]: CustomEvent<any>;
close: CustomEvent<any>;
open: CustomEvent<any>;
},
{ default: {}; heading: {}; label: {} }
> {}

30
types/MultiSelect/MultiSelect.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export type MultiSelectItemId = string;
@ -9,7 +10,8 @@ export interface MultiSelectItem {
text: MultiSelectItemText;
}
export interface MultiSelectProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface MultiSelectProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the multiselect items
* @default []
@ -99,7 +101,9 @@ export interface MultiSelectProps extends svelte.JSX.HTMLAttributes<HTMLElementT
* The default sorting compare the item text value
* @default (a, b) => a.text.localeCompare(b.text, locale, { numeric: true })
*/
sortItem?: ((a: MultiSelectItem, b: MultiSelectItem) => MultiSelectItem) | (() => void);
sortItem?:
| ((a: MultiSelectItem, b: MultiSelectItem) => MultiSelectItem)
| (() => void);
/**
* Override the default translation ids
@ -166,14 +170,14 @@ export interface MultiSelectProps extends svelte.JSX.HTMLAttributes<HTMLElementT
name?: string;
}
export default class MultiSelect {
$$prop_def: MultiSelectProps;
$$slot_def: {};
$on(eventname: "clear", cb: (event: WindowEventMap["clear"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: "focus", cb: (event: WindowEventMap["focus"]) => void): () => void;
$on(eventname: "blur", cb: (event: WindowEventMap["blur"]) => void): () => void;
$on(eventname: "select", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class MultiSelect extends SvelteComponentTyped<
MultiSelectProps,
{
clear: WindowEventMap["clear"];
keydown: WindowEventMap["keydown"];
focus: WindowEventMap["focus"];
blur: WindowEventMap["blur"];
select: CustomEvent<any>;
},
{}
> {}

37
types/Notification/InlineNotification.d.ts vendored
View file

@ -1,11 +1,19 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface InlineNotificationProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface InlineNotificationProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the kind of notification
* @default "error"
*/
kind?: "error" | "info" | "info-square" | "success" | "warning" | "warning-alt";
kind?:
| "error"
| "info"
| "info-square"
| "success"
| "warning"
| "warning-alt";
/**
* Set to `true` to use the low contrast variant
@ -50,17 +58,14 @@ export interface InlineNotificationProps extends svelte.JSX.HTMLAttributes<HTMLE
iconDescription?: string;
}
export default class InlineNotification {
$$prop_def: InlineNotificationProps;
$$slot_def: {
default: {};
actions: {};
};
$on(eventname: "close", cb: (event: CustomEvent<{ timeout: boolean }>) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class InlineNotification extends SvelteComponentTyped<
InlineNotificationProps,
{
close: CustomEvent<{ timeout: boolean }>;
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {}; actions: {} }
> {}

23
types/Notification/NotificationActionButton.d.ts vendored
View file

@ -1,16 +1,15 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface NotificationActionButtonProps {}
export default class NotificationActionButton {
$$prop_def: NotificationActionButtonProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class NotificationActionButton extends SvelteComponentTyped<
NotificationActionButtonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

24
types/Notification/NotificationButton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface NotificationButtonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["button"]> {
export interface NotificationButtonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["button"]> {
/**
* Set the type of notification
* @default "toast"
@ -24,13 +26,13 @@ export interface NotificationButtonProps extends svelte.JSX.HTMLAttributes<HTMLE
iconDescription?: string;
}
export default class NotificationButton {
$$prop_def: NotificationButtonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class NotificationButton extends SvelteComponentTyped<
NotificationButtonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

20
types/Notification/NotificationIcon.d.ts vendored
View file

@ -1,11 +1,18 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface NotificationIconProps {
/**
* Specify the kind of notification icon
* @default "error"
*/
kind?: "error" | "info" | "info-square" | "success" | "warning" | "warning-alt";
kind?:
| "error"
| "info"
| "info-square"
| "success"
| "warning"
| "warning-alt";
/**
* Set the type of notification
@ -20,9 +27,8 @@ export interface NotificationIconProps {
iconDescription?: string;
}
export default class NotificationIcon {
$$prop_def: NotificationIconProps;
$$slot_def: {};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class NotificationIcon extends SvelteComponentTyped<
NotificationIconProps,
{},
{}
> {}

14
types/Notification/NotificationTextDetails.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface NotificationTextDetailsProps {
/**
@ -26,11 +27,8 @@ export interface NotificationTextDetailsProps {
caption?: string;
}
export default class NotificationTextDetails {
$$prop_def: NotificationTextDetailsProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class NotificationTextDetails extends SvelteComponentTyped<
NotificationTextDetailsProps,
{},
{ default: {} }
> {}

36
types/Notification/ToastNotification.d.ts vendored
View file

@ -1,11 +1,19 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ToastNotificationProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface ToastNotificationProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the kind of notification
* @default "error"
*/
kind?: "error" | "info" | "info-square" | "success" | "warning" | "warning-alt";
kind?:
| "error"
| "info"
| "info-square"
| "success"
| "warning"
| "warning-alt";
/**
* Set to `true` to use the low contrast variant
@ -56,16 +64,14 @@ export interface ToastNotificationProps extends svelte.JSX.HTMLAttributes<HTMLEl
hideCloseButton?: boolean;
}
export default class ToastNotification {
$$prop_def: ToastNotificationProps;
$$slot_def: {
default: {};
};
$on(eventname: "close", cb: (event: CustomEvent<{ timeout: boolean }>) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ToastNotification extends SvelteComponentTyped<
ToastNotificationProps,
{
close: CustomEvent<{ timeout: boolean }>;
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

30
types/NumberInput/NumberInput.d.ts vendored
View file

@ -1,8 +1,10 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export type NumberInputTranslationId = "increment" | "decrement";
export interface NumberInputProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface NumberInputProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the size of the input
*/
@ -139,17 +141,15 @@ export interface NumberInputProps extends svelte.JSX.HTMLAttributes<HTMLElementT
ref?: null | HTMLInputElement;
}
export default class NumberInput {
$$prop_def: NumberInputProps;
$$slot_def: {
label: {};
};
$on(eventname: "change", cb: (event: CustomEvent<number>) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "input", cb: (event: WindowEventMap["input"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class NumberInput extends SvelteComponentTyped<
NumberInputProps,
{
change: CustomEvent<number>;
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
input: WindowEventMap["input"];
},
{ label: {} }
> {}

24
types/NumberInput/NumberInputSkeleton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface NumberInputSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface NumberInputSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to hide the label text
* @default false
@ -8,13 +10,13 @@ export interface NumberInputSkeletonProps extends svelte.JSX.HTMLAttributes<HTML
hideLabel?: boolean;
}
export default class NumberInputSkeleton {
$$prop_def: NumberInputSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class NumberInputSkeleton extends SvelteComponentTyped<
NumberInputSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

26
types/OrderedList/OrderedList.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface OrderedListProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["ol"]> {
export interface OrderedListProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["ol"]> {
/**
* Set to `true` to use the nested variant
* @default false
@ -14,15 +16,13 @@ export interface OrderedListProps extends svelte.JSX.HTMLAttributes<HTMLElementT
native?: boolean;
}
export default class OrderedList {
$$prop_def: OrderedListProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class OrderedList extends SvelteComponentTyped<
OrderedListProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

31
types/OverflowMenu/OverflowMenu.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface OverflowMenuProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["button"]> {
export interface OverflowMenuProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["button"]> {
/**
* Specify the size of the overflow menu
*/
@ -70,18 +72,15 @@ export interface OverflowMenuProps extends svelte.JSX.HTMLAttributes<HTMLElement
menuRef?: null | HTMLUListElement;
}
export default class OverflowMenu {
$$prop_def: OverflowMenuProps;
$$slot_def: {
default: {};
menu: {};
};
$on(eventname: "close", cb: (event: CustomEvent<{ index: number; text: string }>) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class OverflowMenu extends SvelteComponentTyped<
OverflowMenuProps,
{
close: CustomEvent<{ index: number; text: string }>;
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
keydown: WindowEventMap["keydown"];
},
{ default: {}; menu: {} }
> {}

19
types/OverflowMenu/OverflowMenuItem.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface OverflowMenuItemProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["li"]> {
export interface OverflowMenuItemProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["li"]> {
/**
* Specify the item text
* Alternatively, use the default slot for a custom element
@ -57,13 +59,8 @@ export interface OverflowMenuItemProps extends svelte.JSX.HTMLAttributes<HTMLEle
ref?: null | HTMLAnchorElement | HTMLButtonElement;
}
export default class OverflowMenuItem {
$$prop_def: OverflowMenuItemProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class OverflowMenuItem extends SvelteComponentTyped<
OverflowMenuItemProps,
{ click: WindowEventMap["click"]; keydown: WindowEventMap["keydown"] },
{ default: {} }
> {}

16
types/Pagination/Pagination.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface PaginationProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface PaginationProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the current page index
* @default 1
@ -98,10 +100,8 @@ export interface PaginationProps extends svelte.JSX.HTMLAttributes<HTMLElementTa
id?: string;
}
export default class Pagination {
$$prop_def: PaginationProps;
$$slot_def: {};
$on(eventname: "update", cb: (event: CustomEvent<{ pageSize: number; page: number }>) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Pagination extends SvelteComponentTyped<
PaginationProps,
{ update: CustomEvent<{ pageSize: number; page: number }> },
{}
> {}

24
types/Pagination/PaginationSkeleton.d.ts vendored
View file

@ -1,14 +1,16 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface PaginationSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export interface PaginationSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export default class PaginationSkeleton {
$$prop_def: PaginationSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class PaginationSkeleton extends SvelteComponentTyped<
PaginationSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

22
types/PaginationNav/PaginationNav.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface PaginationNavProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["nav"]> {
export interface PaginationNavProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["nav"]> {
/**
* Specify the current page index
* @default 0
@ -38,12 +40,12 @@ export interface PaginationNavProps extends svelte.JSX.HTMLAttributes<HTMLElemen
backwardText?: string;
}
export default class PaginationNav {
$$prop_def: PaginationNavProps;
$$slot_def: {};
$on(eventname: "change", cb: (event: CustomEvent<{ page: number }>) => void): () => void;
$on(eventname: "click:button--previous", cb: (event: CustomEvent<{ page: number }>) => void): () => void;
$on(eventname: "click:button--next", cb: (event: CustomEvent<{ page: number }>) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class PaginationNav extends SvelteComponentTyped<
PaginationNavProps,
{
change: CustomEvent<{ page: number }>;
["click:button--previous"]: CustomEvent<{ page: number }>;
["click:button--next"]: CustomEvent<{ page: number }>;
},
{}
> {}

28
types/ProgressIndicator/ProgressIndicator.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ProgressIndicatorProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["ul"]> {
export interface ProgressIndicatorProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["ul"]> {
/**
* Specify the current step index
* @default 0
@ -26,16 +28,14 @@ export interface ProgressIndicatorProps extends svelte.JSX.HTMLAttributes<HTMLEl
preventChangeOnClick?: boolean;
}
export default class ProgressIndicator {
$$prop_def: ProgressIndicatorProps;
$$slot_def: {
default: {};
};
$on(eventname: "change", cb: (event: CustomEvent<number>) => void): () => void;
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ProgressIndicator extends SvelteComponentTyped<
ProgressIndicatorProps,
{
change: CustomEvent<number>;
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{ default: {} }
> {}

24
types/ProgressIndicator/ProgressIndicatorSkeleton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ProgressIndicatorSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["ul"]> {
export interface ProgressIndicatorSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["ul"]> {
/**
* Set to `true` to use the vertical variant
* @default false
@ -14,13 +16,13 @@ export interface ProgressIndicatorSkeletonProps extends svelte.JSX.HTMLAttribute
count?: number;
}
export default class ProgressIndicatorSkeleton {
$$prop_def: ProgressIndicatorSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ProgressIndicatorSkeleton extends SvelteComponentTyped<
ProgressIndicatorSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

28
types/ProgressIndicator/ProgressStep.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface ProgressStepProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["li"]> {
export interface ProgressStepProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["li"]> {
/**
* Set to `true` for the complete variant
* @default false
@ -50,16 +52,14 @@ export interface ProgressStepProps extends svelte.JSX.HTMLAttributes<HTMLElement
id?: string;
}
export default class ProgressStep {
$$prop_def: ProgressStepProps;
$$slot_def: {
default: { props: { class: "bx--progress-label" } };
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class ProgressStep extends SvelteComponentTyped<
ProgressStepProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
keydown: WindowEventMap["keydown"];
},
{ default: { props: { class: "bx--progress-label" } } }
> {}

16
types/RadioButton/RadioButton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface RadioButtonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface RadioButtonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the value of the radio button
* @default ""
@ -56,10 +58,8 @@ export interface RadioButtonProps extends svelte.JSX.HTMLAttributes<HTMLElementT
ref?: null | HTMLInputElement;
}
export default class RadioButton {
$$prop_def: RadioButtonProps;
$$slot_def: {};
$on(eventname: "change", cb: (event: WindowEventMap["change"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class RadioButton extends SvelteComponentTyped<
RadioButtonProps,
{ change: WindowEventMap["change"] },
{}
> {}

24
types/RadioButton/RadioButtonSkeleton.d.ts vendored
View file

@ -1,14 +1,16 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface RadioButtonSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export interface RadioButtonSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export default class RadioButtonSkeleton {
$$prop_def: RadioButtonSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class RadioButtonSkeleton extends SvelteComponentTyped<
RadioButtonSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

28
types/RadioButtonGroup/RadioButtonGroup.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface RadioButtonGroupProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface RadioButtonGroupProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set the selected radio button value
*/
@ -30,16 +32,14 @@ export interface RadioButtonGroupProps extends svelte.JSX.HTMLAttributes<HTMLEle
id?: string;
}
export default class RadioButtonGroup {
$$prop_def: RadioButtonGroupProps;
$$slot_def: {
default: {};
};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "change", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class RadioButtonGroup extends SvelteComponentTyped<
RadioButtonGroupProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
change: CustomEvent<any>;
},
{ default: {} }
> {}

33
types/Search/Search.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface SearchProps {
/**
@ -85,19 +86,19 @@ export interface SearchProps {
ref?: null | HTMLInputElement;
}
export default class Search {
$$prop_def: SearchProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: "change", cb: (event: WindowEventMap["change"]) => void): () => void;
$on(eventname: "input", cb: (event: WindowEventMap["input"]) => void): () => void;
$on(eventname: "focus", cb: (event: WindowEventMap["focus"]) => void): () => void;
$on(eventname: "blur", cb: (event: WindowEventMap["blur"]) => void): () => void;
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void;
$on(eventname: "clear", cb: (event: CustomEvent<any>) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Search extends SvelteComponentTyped<
SearchProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
change: WindowEventMap["change"];
input: WindowEventMap["input"];
focus: WindowEventMap["focus"];
blur: WindowEventMap["blur"];
keydown: WindowEventMap["keydown"];
clear: CustomEvent<any>;
},
{}
> {}

24
types/Search/SearchSkeleton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface SearchSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface SearchSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* @default false
*/
@ -13,13 +15,13 @@ export interface SearchSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLEleme
size?: "sm" | "lg" | "xl";
}
export default class SearchSkeleton {
$$prop_def: SearchSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class SearchSkeleton extends SvelteComponentTyped<
SearchSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

19
types/Select/Select.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface SelectProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface SelectProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the selected item value
*/
@ -83,13 +85,8 @@ export interface SelectProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNam
ref?: null | HTMLSelectElement;
}
export default class Select {
$$prop_def: SelectProps;
$$slot_def: {
default: {};
};
$on(eventname: "change", cb: (event: CustomEvent<string>) => void): () => void;
$on(eventname: "blur", cb: (event: WindowEventMap["blur"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class Select extends SvelteComponentTyped<
SelectProps,
{ change: CustomEvent<string>; blur: WindowEventMap["blur"] },
{ default: {} }
> {}

12
types/Select/SelectItem.d.ts vendored
View file

@ -1,4 +1,5 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface SelectItemProps {
/**
@ -26,9 +27,8 @@ export interface SelectItemProps {
disabled?: boolean;
}
export default class SelectItem {
$$prop_def: SelectItemProps;
$$slot_def: {};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class SelectItem extends SvelteComponentTyped<
SelectItemProps,
{},
{}
> {}

17
types/Select/SelectItemGroup.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface SelectItemGroupProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["optgroup"]> {
export interface SelectItemGroupProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["optgroup"]> {
/**
* Set to `true` to disable the optgroup element
* @default false
@ -14,11 +16,8 @@ export interface SelectItemGroupProps extends svelte.JSX.HTMLAttributes<HTMLElem
label?: string;
}
export default class SelectItemGroup {
$$prop_def: SelectItemGroupProps;
$$slot_def: {
default: {};
};
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class SelectItemGroup extends SvelteComponentTyped<
SelectItemGroupProps,
{},
{ default: {} }
> {}

24
types/Select/SelectSkeleton.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface SelectSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface SelectSkeletonProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Set to `true` to hide the label text
* @default false
@ -8,13 +10,13 @@ export interface SelectSkeletonProps extends svelte.JSX.HTMLAttributes<HTMLEleme
hideLabel?: boolean;
}
export default class SelectSkeleton {
$$prop_def: SelectSkeletonProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class SelectSkeleton extends SvelteComponentTyped<
SelectSkeletonProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

24
types/SkeletonPlaceholder/SkeletonPlaceholder.d.ts vendored
View file

@ -1,14 +1,16 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface SkeletonPlaceholderProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export interface SkeletonPlaceholderProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {}
export default class SkeletonPlaceholder {
$$prop_def: SkeletonPlaceholderProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class SkeletonPlaceholder extends SvelteComponentTyped<
SkeletonPlaceholderProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

24
types/SkeletonText/SkeletonText.d.ts vendored
View file

@ -1,6 +1,8 @@
/// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface SkeletonTextProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
export interface SkeletonTextProps
extends svelte.JSX.HTMLAttributes<HTMLElementTagNameMap["div"]> {
/**
* Specify the number of lines to render
* @default 3
@ -26,13 +28,13 @@ export interface SkeletonTextProps extends svelte.JSX.HTMLAttributes<HTMLElement
width?: string;
}
export default class SkeletonText {
$$prop_def: SkeletonTextProps;
$$slot_def: {};
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void;
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void;
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void;
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void;
$on(eventname: string, cb: (event: Event) => void): () => void;
}
export default class SkeletonText extends SvelteComponentTyped<
SkeletonTextProps,
{
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{}
> {}

Some files were not shown because too many files have changed in this diff Show more