mcp/carbon-components-svelte
1
0
Fork 0
mirror of https://github.com/carbon-design-system/carbon-components-svelte.git synced 2025-09-15 02:11:05 +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

8894
docs/src/COMPONENT_API.json
View file

File diff suppressed because it is too large Load diff

2
package.json
View file

@ -41,7 +41,7 @@
"rollup-plugin-svelte": "^7.1.0", "rollup-plugin-svelte": "^7.1.0",
"rollup-plugin-terser": "^7.0.2", "rollup-plugin-terser": "^7.0.2",
"sass": "^1.32.6", "sass": "^1.32.6",
"sveld": "0.3.0", "sveld": "^0.7.0",
"svelte": "^3.32.1", "svelte": "^3.32.1",
"svelte-check": "^1.1.32", "svelte-check": "^1.1.32",
"typescript": "^4.1.3" "typescript": "^4.1.3"

1
rollup.config.js
View file

@ -24,6 +24,7 @@ export default ["es", "umd"].map((format) => {
UMD && terser(), UMD && terser(),
UMD && UMD &&
sveld({ sveld({
glob: true,
markdown: true, markdown: true,
markdownOptions: { markdownOptions: {
onAppend: (type, document, components) => { onAppend: (type, document, components) => {

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

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

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

@ -1,6 +1,8 @@
/// <reference types="svelte" /> /// <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 * Specify the title of the accordion item heading
* Alternatively, use the "title" slot (e.g., <div slot="title">...</div>) * 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; iconDescription?: string;
} }
export default class AccordionItem { export default class AccordionItem extends SvelteComponentTyped<
$$prop_def: AccordionItemProps; AccordionItemProps,
$$slot_def: { {
default: {}; animationend: WindowEventMap["animationend"];
title: {}; click: WindowEventMap["click"];
}; mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "animationend", cb: (event: WindowEventMap["animationend"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; keydown: WindowEventMap["keydown"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; },
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; { default: {}; title: {} }
$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;
}

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

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

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

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

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

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

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

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

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

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

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

@ -1,4 +1,5 @@
/// <reference types="svelte" /> /// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { ButtonSkeletonProps } from "./ButtonSkeleton"; import { ButtonSkeletonProps } from "./ButtonSkeleton";
export interface ButtonProps export interface ButtonProps
@ -10,7 +11,14 @@ export interface ButtonProps
* Specify the kind of button * Specify the kind of button
* @default "primary" * @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 * Specify the size of button
@ -90,9 +98,15 @@ export interface ButtonProps
ref?: null | HTMLAnchorElement | HTMLButtonElement; ref?: null | HTMLAnchorElement | HTMLButtonElement;
} }
export default class Button { export default class Button extends SvelteComponentTyped<
$$prop_def: ButtonProps; ButtonProps,
$$slot_def: { {
click: WindowEventMap["click"];
mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
mouseleave: WindowEventMap["mouseleave"];
},
{
default: { default: {
props: { props: {
role: "button"; role: "button";
@ -104,11 +118,5 @@ export default class Button {
[key: string]: any; [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" /> /// <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 * Set to `true` to stack the buttons vertically
* @default false * @default false
@ -8,11 +10,8 @@ export interface ButtonSetProps extends svelte.JSX.HTMLAttributes<HTMLElementTag
stacked?: boolean; stacked?: boolean;
} }
export default class ButtonSet { export default class ButtonSet extends SvelteComponentTyped<
$$prop_def: ButtonSetProps; ButtonSetProps,
$$slot_def: { {},
default: {}; { default: {} }
}; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

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

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

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

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

@ -1,14 +1,16 @@
/// <reference types="svelte" /> /// <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 { export default class CheckboxSkeleton extends SvelteComponentTyped<
$$prop_def: CheckboxSkeletonProps; CheckboxSkeletonProps,
$$slot_def: {}; {
click: WindowEventMap["click"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseover: WindowEventMap["mouseover"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; },
$on(eventname: string, cb: (event: Event) => void): () => void; {}
} > {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -1,6 +1,8 @@
/// <reference types="svelte" /> /// <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 * Specify the switch text
* Alternatively, use the "text" slot (e.g., <span slot="text">...</span>) * 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; ref?: null | HTMLButtonElement;
} }
export default class Switch { export default class Switch extends SvelteComponentTyped<
$$prop_def: SwitchProps; SwitchProps,
$$slot_def: { {
default: {}; click: WindowEventMap["click"];
}; mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; keydown: WindowEventMap["keydown"];
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; },
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; { default: {} }
$on(eventname: "keydown", cb: (event: WindowEventMap["keydown"]) => void): () => void; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

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

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

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

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

@ -1,4 +1,5 @@
/// <reference types="svelte" /> /// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export type DataTableKey = string; export type DataTableKey = string;
@ -128,31 +129,32 @@ export interface DataTableProps {
stickyHeader?: boolean; stickyHeader?: boolean;
} }
export default class DataTable { export default class DataTable extends SvelteComponentTyped<
$$prop_def: DataTableProps; DataTableProps,
$$slot_def: { {
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: {}; default: {};
cell: { row: DataTableRow; cell: DataTableCell }; cell: { row: DataTableRow; cell: DataTableCell };
["cell-header"]: { header: DataTableNonEmptyHeader }; ["cell-header"]: { header: DataTableNonEmptyHeader };
["expanded-row"]: { row: DataTableRow }; ["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" /> /// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { DataTableHeader } from "../DataTable/DataTable"; import { DataTableHeader } from "../DataTable/DataTable";
export interface DataTableSkeletonProps export interface DataTableSkeletonProps
@ -48,13 +49,13 @@ export interface DataTableSkeletonProps
showToolbar?: boolean; showToolbar?: boolean;
} }
export default class DataTableSkeleton { export default class DataTableSkeleton extends SvelteComponentTyped<
$$prop_def: DataTableSkeletonProps; DataTableSkeletonProps,
$$slot_def: {}; {
click: WindowEventMap["click"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseover: WindowEventMap["mouseover"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; },
$on(eventname: string, cb: (event: Event) => void): () => void; {}
} > {}

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

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

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

@ -1,12 +1,11 @@
/// <reference types="svelte" /> /// <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 { export default class TableBody extends SvelteComponentTyped<
$$prop_def: TableBodyProps; TableBodyProps,
$$slot_def: { {},
default: {}; { default: {} }
}; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

@ -1,16 +1,16 @@
/// <reference types="svelte" /> /// <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 { export default class TableCell extends SvelteComponentTyped<
$$prop_def: TableCellProps; TableCellProps,
$$slot_def: { {
default: {}; click: WindowEventMap["click"];
}; mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; },
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; { default: {} }
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

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

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

@ -1,16 +1,16 @@
/// <reference types="svelte" /> /// <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 { export default class TableHead extends SvelteComponentTyped<
$$prop_def: TableHeadProps; TableHeadProps,
$$slot_def: { {
default: {}; click: WindowEventMap["click"];
}; mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; },
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; { default: {} }
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

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

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

@ -1,16 +1,16 @@
/// <reference types="svelte" /> /// <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 { export default class TableRow extends SvelteComponentTyped<
$$prop_def: TableRowProps; TableRowProps,
$$slot_def: { {
default: {}; click: WindowEventMap["click"];
}; mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; },
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; { default: {} }
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

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

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

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

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

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

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

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

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

@ -1,15 +1,11 @@
/// <reference types="svelte" /> /// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
import { OverflowMenuItemProps } from "../OverflowMenu/OverflowMenuItem"; import { OverflowMenuItemProps } from "../OverflowMenu/OverflowMenuItem";
export interface ToolbarMenuItemProps extends OverflowMenuItemProps {} export interface ToolbarMenuItemProps extends OverflowMenuItemProps {}
export default class ToolbarMenuItem { export default class ToolbarMenuItem extends SvelteComponentTyped<
$$prop_def: ToolbarMenuItemProps; ToolbarMenuItemProps,
$$slot_def: { { click: WindowEventMap["click"]; keydown: WindowEventMap["keydown"] },
default: {}; { 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;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -1,14 +1,16 @@
/// <reference types="svelte" /> /// <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 { export default class FileUploaderSkeleton extends SvelteComponentTyped<
$$prop_def: FileUploaderSkeletonProps; FileUploaderSkeletonProps,
$$slot_def: {}; {
click: WindowEventMap["click"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseover: WindowEventMap["mouseover"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; },
$on(eventname: string, cb: (event: Event) => void): () => void; {}
} > {}

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

@ -1,4 +1,5 @@
/// <reference types="svelte" /> /// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export interface FilenameProps { export interface FilenameProps {
/** /**
@ -20,11 +21,8 @@ export interface FilenameProps {
invalid?: boolean; invalid?: boolean;
} }
export default class Filename { export default class Filename extends SvelteComponentTyped<
$$prop_def: FilenameProps; FilenameProps,
$$slot_def: {}; { click: WindowEventMap["click"]; keydown: WindowEventMap["keydown"] },
{}
$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;
}

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

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

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

@ -1,17 +1,17 @@
/// <reference types="svelte" /> /// <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 { export default class Form extends SvelteComponentTyped<
$$prop_def: FormProps; FormProps,
$$slot_def: { {
default: {}; click: WindowEventMap["click"];
}; mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; submit: WindowEventMap["submit"];
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; },
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; { default: {} }
$on(eventname: "submit", cb: (event: WindowEventMap["submit"]) => void): () => void; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

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

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

@ -1,16 +1,16 @@
/// <reference types="svelte" /> /// <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 { export default class FormItem extends SvelteComponentTyped<
$$prop_def: FormItemProps; FormItemProps,
$$slot_def: { {
default: {}; click: WindowEventMap["click"];
}; mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; },
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; { default: {} }
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

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

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

@ -1,4 +1,5 @@
/// <reference types="svelte" /> /// <reference types="svelte" />
import { SvelteComponentTyped } from "svelte";
export type ColumnSize = boolean | number; export type ColumnSize = boolean | number;
@ -9,7 +10,8 @@ export interface ColumnSizeDescriptor {
export type ColumnBreakpoint = ColumnSize | 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 * 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>) * 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; max?: ColumnBreakpoint;
} }
export default class Column { export default class Column extends SvelteComponentTyped<
$$prop_def: ColumnProps; ColumnProps,
$$slot_def: { {},
default: { props: { class: string; [key: string]: any } }; { default: { props: { class: string; [key: string]: any } } }
}; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

@ -1,6 +1,8 @@
/// <reference types="svelte" /> /// <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 * 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>) * 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; padding?: boolean;
} }
export default class Grid { export default class Grid extends SvelteComponentTyped<
$$prop_def: GridProps; GridProps,
$$slot_def: { {},
default: { props: { class: string; [key: string]: any } }; { default: { props: { class: string; [key: string]: any } } }
}; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

@ -1,6 +1,8 @@
/// <reference types="svelte" /> /// <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 * 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>) * 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; padding?: boolean;
} }
export default class Row { export default class Row extends SvelteComponentTyped<
$$prop_def: RowProps; RowProps,
$$slot_def: { {},
default: { props: { class: string; [key: string]: any } }; { default: { props: { class: string; [key: string]: any } } }
}; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

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

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

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

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

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

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

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

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

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

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

@ -1,6 +1,8 @@
/// <reference types="svelte" /> /// <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 * Set the size of the list box
*/ */
@ -55,13 +57,8 @@ export interface ListBoxProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNa
warnText?: string; warnText?: string;
} }
export default class ListBox { export default class ListBox extends SvelteComponentTyped<
$$prop_def: ListBoxProps; ListBoxProps,
$$slot_def: { { keydown: WindowEventMap["keydown"]; click: WindowEventMap["click"] },
default: {}; { 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;
}

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

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

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

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

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

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

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

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

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

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

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

@ -1,16 +1,16 @@
/// <reference types="svelte" /> /// <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 { export default class ListItem extends SvelteComponentTyped<
$$prop_def: ListItemProps; ListItemProps,
$$slot_def: { {
default: {}; click: WindowEventMap["click"];
}; mouseover: WindowEventMap["mouseover"];
mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; },
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; { default: {} }
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; > {}
$on(eventname: string, cb: (event: Event) => void): () => void;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -1,6 +1,8 @@
/// <reference types="svelte" /> /// <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 * Specify the item text
* Alternatively, use the default slot for a custom element * 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; ref?: null | HTMLAnchorElement | HTMLButtonElement;
} }
export default class OverflowMenuItem { export default class OverflowMenuItem extends SvelteComponentTyped<
$$prop_def: OverflowMenuItemProps; OverflowMenuItemProps,
$$slot_def: { { click: WindowEventMap["click"]; keydown: WindowEventMap["keydown"] },
default: {}; { 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;
}

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

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

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

@ -1,14 +1,16 @@
/// <reference types="svelte" /> /// <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 { export default class PaginationSkeleton extends SvelteComponentTyped<
$$prop_def: PaginationSkeletonProps; PaginationSkeletonProps,
$$slot_def: {}; {
click: WindowEventMap["click"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseover: WindowEventMap["mouseover"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; },
$on(eventname: string, cb: (event: Event) => void): () => void; {}
} > {}

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

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

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

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

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

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

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

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

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

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

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

@ -1,14 +1,16 @@
/// <reference types="svelte" /> /// <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 { export default class RadioButtonSkeleton extends SvelteComponentTyped<
$$prop_def: RadioButtonSkeletonProps; RadioButtonSkeletonProps,
$$slot_def: {}; {
click: WindowEventMap["click"];
$on(eventname: "click", cb: (event: WindowEventMap["click"]) => void): () => void; mouseover: WindowEventMap["mouseover"];
$on(eventname: "mouseover", cb: (event: WindowEventMap["mouseover"]) => void): () => void; mouseenter: WindowEventMap["mouseenter"];
$on(eventname: "mouseenter", cb: (event: WindowEventMap["mouseenter"]) => void): () => void; mouseleave: WindowEventMap["mouseleave"];
$on(eventname: "mouseleave", cb: (event: WindowEventMap["mouseleave"]) => void): () => void; },
$on(eventname: string, cb: (event: Event) => void): () => void; {}
} > {}

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

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

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

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

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

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

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

@ -1,6 +1,8 @@
/// <reference types="svelte" /> /// <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 * Specify the selected item value
*/ */
@ -83,13 +85,8 @@ export interface SelectProps extends svelte.JSX.HTMLAttributes<HTMLElementTagNam
ref?: null | HTMLSelectElement; ref?: null | HTMLSelectElement;
} }
export default class Select { export default class Select extends SvelteComponentTyped<
$$prop_def: SelectProps; SelectProps,
$$slot_def: { { change: CustomEvent<string>; blur: WindowEventMap["blur"] },
default: {}; { 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;
}

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

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

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

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

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