flowbite-svelte 0.27.15 → 0.27.16

package/forms/Input.svelte.d.ts

@@ -0,0 +1,45 @@
+import { SvelteComponentTyped } from "svelte";
+import type { SizeType, FormSizeType } from '../types';
+export declare function clampSize(s: SizeType): "sm" | "md" | "lg";
+import type { InputType } from '../types';
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        type?: InputType | undefined;
+        value?: string | number | undefined;
+        size?: FormSizeType | undefined;
+        defaultClass?: string | undefined;
+        color?: "red" | "green" | "base" | undefined;
+    };
+    events: {
+        blur: FocusEvent;
+        change: Event;
+        click: MouseEvent;
+        focus: FocusEvent;
+        keydown: KeyboardEvent;
+        keypress: KeyboardEvent;
+        keyup: KeyboardEvent;
+        mouseover: MouseEvent;
+        mouseenter: MouseEvent;
+        mouseleave: MouseEvent;
+        paste: ClipboardEvent;
+        input: Event;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        left: {};
+        default: {
+            props: {
+                class: string;
+            };
+        };
+        right: {};
+    };
+};
+export declare type InputProps = typeof __propDef.props;
+export declare type InputEvents = typeof __propDef.events;
+export declare type InputSlots = typeof __propDef.slots;
+export default class Input extends SvelteComponentTyped<InputProps, InputEvents, InputSlots> {
+}
+export {};

package/forms/InputAddon.svelte

@@ -0,0 +1,29 @@
+<script>import classNames from 'classnames';
+import { getContext } from 'svelte';
+import { clampSize } from './Input.svelte';
+export let size = undefined;
+// tinted if put in component having its own background
+let background = getContext('background');
+let group = getContext('group');
+const borderClasses = {
+    base: 'border-gray-300 dark:border-gray-600',
+    tinted: 'border-gray-300 dark:border-gray-500'
+};
+const darkBgClasses = {
+    base: 'dark:bg-gray-600 dark:text-gray-400',
+    tinted: 'dark:bg-gray-500 dark:text-gray-300'
+};
+const divider = {
+    base: 'dark:border-r-gray-700 dark:last:border-r-gray-600',
+    tinted: 'dark:border-r-gray-600 dark:last:border-r-gray-500'
+};
+const textSizes = { sm: 'sm:text-xs', md: 'text-sm', lg: 'sm:text-base' };
+const prefixPadding = { sm: 'px-2', md: 'px-3', lg: 'px-4' };
+// size: explicit, inherited, default
+$: _size = size || clampSize(group?.size) || 'md';
+$: divClass = classNames(textSizes[_size], prefixPadding[_size], background ? borderClasses['tinted'] : borderClasses['base'], 'text-gray-500 bg-gray-200', background ? darkBgClasses.tinted : darkBgClasses.base, background ? divider.tinted : divider.base, 'inline-flex items-center border-t border-b first:border-l border-r', 'first:rounded-l-lg last:rounded-r-lg', $$props.class);
+</script>
+
+<div {...$$restProps} class={divClass}>
+  <slot />
+</div>

package/forms/InputAddon.svelte.d.ts

@@ -0,0 +1,19 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        size?: 'sm' | 'md' | 'lg' | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type InputAddonProps = typeof __propDef.props;
+export declare type InputAddonEvents = typeof __propDef.events;
+export declare type InputAddonSlots = typeof __propDef.slots;
+export default class InputAddon extends SvelteComponentTyped<InputAddonProps, InputAddonEvents, InputAddonSlots> {
+}
+export {};

package/forms/Label.svelte

@@ -0,0 +1,25 @@
+<script>import classNames from 'classnames';
+export let color = 'gray';
+export let defaultClass = 'text-sm font-medium block';
+export let show = true;
+let node;
+const colorClasses = {
+    gray: 'text-gray-900 dark:text-gray-300',
+    green: 'text-green-700 dark:text-green-500',
+    red: 'text-red-700 dark:text-red-500',
+    disabled: 'text-gray-400 dark:text-gray-500'
+};
+// function checkDisabled(node: HTMLLabelElement) {
+$: {
+    const control = node?.control;
+    color = control?.disabled ? 'disabled' : color;
+}
+$: labelClass = classNames(defaultClass, colorClasses[color], $$props.class);
+</script>
+
+{#if show}
+  <!-- svelte-ignore a11y-label-has-associated-control -->
+  <label bind:this={node} {...$$restProps} class={labelClass}><slot /></label>
+{:else}
+  <slot />
+{/if}

package/forms/Label.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        color?: "gray" | "red" | "green" | "disabled" | undefined;
+        defaultClass?: string | undefined;
+        show?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type LabelProps = typeof __propDef.props;
+export declare type LabelEvents = typeof __propDef.events;
+export declare type LabelSlots = typeof __propDef.slots;
+export default class Label extends SvelteComponentTyped<LabelProps, LabelEvents, LabelSlots> {
+}
+export {};

package/forms/NumberInput.svelte

@@ -0,0 +1,7 @@
+<script>import Input from './Input.svelte';
+export let value = 0;
+</script>
+
+<Input let:props {...$$restProps}>
+  <input {...props} type="number" bind:value />
+</Input>

package/forms/NumberInput.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        value?: number | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type NumberInputProps = typeof __propDef.props;
+export declare type NumberInputEvents = typeof __propDef.events;
+export declare type NumberInputSlots = typeof __propDef.slots;
+export default class NumberInput extends SvelteComponentTyped<NumberInputProps, NumberInputEvents, NumberInputSlots> {
+}
+export {};

package/forms/Radio.svelte

@@ -0,0 +1,45 @@
+<script context="module">// this part is shared between Radio and Checkbox
+import classNames from 'classnames';
+const colorClasses = {
+    red: 'text-red-600 focus:ring-red-500 dark:focus:ring-red-600',
+    green: 'text-green-600 focus:ring-green-500 dark:focus:ring-green-600',
+    purple: 'text-purple-600 focus:ring-purple-500 dark:focus:ring-purple-600',
+    teal: 'text-teal-600 focus:ring-teal-500 dark:focus:ring-teal-600',
+    yellow: 'text-yellow-400 focus:ring-yellow-500 dark:focus:ring-yellow-600',
+    orange: 'text-orange-500 focus:ring-orange-500 dark:focus:ring-orange-600',
+    blue: 'text-blue-600 focus:ring-blue-500 dark:focus:ring-blue-600'
+};
+export const labelClass = (inline, extraClass) => classNames(inline ? 'inline-flex' : 'flex', 'items-center', extraClass);
+export const inputClass = (custom, color, rounded, tinted, extraClass) => classNames('w-4 h-4 bg-gray-100 border-gray-300 dark:ring-offset-gray-800 focus:ring-2', extraClass === true && 'mr-2', tinted ? 'dark:bg-gray-600 dark:border-gray-500' : 'dark:bg-gray-700 dark:border-gray-600', custom && 'sr-only peer', rounded && 'rounded', colorClasses[color], extraClass);
+</script>
+
+<script>import { getContext } from 'svelte';
+import Label from './Label.svelte';
+export let color = 'blue';
+export let custom = false;
+export let inline = false;
+export let group = '';
+export let value = '';
+// tinted if put in component having its own background
+let background = getContext('background');
+</script>
+
+<Label class={labelClass(inline, $$props.class)} show={$$slots.default}>
+  <input
+    type="radio"
+    bind:group
+    on:blur
+    on:change
+    on:click
+    on:focus
+    on:keydown
+    on:keypress
+    on:keyup
+    on:mouseenter
+    on:mouseleave
+    on:mouseover
+    on:paste
+    {value}
+    {...$$restProps}
+    class={inputClass(custom, color, false, background, $$slots.default || $$props.class)} /><slot />
+</Label>

package/forms/Radio.svelte.d.ts

@@ -0,0 +1,38 @@
+import { SvelteComponentTyped } from "svelte";
+export declare const labelClass: (inline: boolean, extraClass: string) => string;
+export declare const inputClass: (custom: boolean, color: FormColorType, rounded: boolean, tinted: boolean, extraClass: string | boolean) => string;
+import type { FormColorType } from '../types';
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        color?: FormColorType | undefined;
+        custom?: boolean | undefined;
+        inline?: boolean | undefined;
+        group?: string | number | undefined;
+        value?: string | number | undefined;
+    };
+    events: {
+        blur: FocusEvent;
+        change: Event;
+        click: MouseEvent;
+        focus: FocusEvent;
+        keydown: KeyboardEvent;
+        keypress: KeyboardEvent;
+        keyup: KeyboardEvent;
+        mouseenter: MouseEvent;
+        mouseleave: MouseEvent;
+        mouseover: MouseEvent;
+        paste: ClipboardEvent;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type RadioProps = typeof __propDef.props;
+export declare type RadioEvents = typeof __propDef.events;
+export declare type RadioSlots = typeof __propDef.slots;
+export default class Radio extends SvelteComponentTyped<RadioProps, RadioEvents, RadioSlots> {
+}
+export {};

package/forms/RadioInline.svelte.d.ts

@@ -0,0 +1,23 @@
+/** @typedef {typeof __propDef.props}  RadioInlineProps */
+/** @typedef {typeof __propDef.events}  RadioInlineEvents */
+/** @typedef {typeof __propDef.slots}  RadioInlineSlots */
+export default class RadioInline extends SvelteComponentTyped<{}, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}> {
+}
+export type RadioInlineProps = typeof __propDef.props;
+export type RadioInlineEvents = typeof __propDef.events;
+export type RadioInlineSlots = typeof __propDef.slots;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {};
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export {};

package/forms/Range.svelte

@@ -0,0 +1,22 @@
+<script>import classNames from 'classnames';
+export let value;
+export let size = 'md';
+const sizes = {
+    sm: 'h-1 range-sm',
+    md: 'h-2',
+    lg: 'h-3 range-lg'
+};
+let inputClass;
+$: inputClass = classNames('w-full bg-gray-200 rounded-lg appearance-none cursor-pointer dark:bg-gray-700', sizes[size] ?? sizes.md, $$props.class);
+</script>
+
+<input
+	type="range"
+	bind:value
+	{...$$restProps}
+	class={inputClass}
+	on:change
+	on:click
+	on:keydown
+	on:keypress
+	on:keyup />

package/forms/Range.svelte.d.ts

@@ -0,0 +1,24 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        value: number;
+        size?: "sm" | "md" | "lg" | undefined;
+    };
+    events: {
+        change: Event;
+        click: MouseEvent;
+        keydown: KeyboardEvent;
+        keypress: KeyboardEvent;
+        keyup: KeyboardEvent;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type RangeProps = typeof __propDef.props;
+export declare type RangeEvents = typeof __propDef.events;
+export declare type RangeSlots = typeof __propDef.slots;
+export default class Range extends SvelteComponentTyped<RangeProps, RangeEvents, RangeSlots> {
+}
+export {};

package/forms/Search.svelte

@@ -0,0 +1,55 @@
+<script>import Wrapper from '../utils/Wrapper.svelte';
+import Input from './Input.svelte';
+export let size = 'lg';
+export let placeholder = 'Search';
+const sizes = {
+    sm: 'w-3.5 h-3.5',
+    md: 'w-5 h-5',
+    lg: 'w-6 h-6'
+};
+</script>
+
+<Wrapper class="relative w-full" show={$$slots.default}>
+  <Input
+    on:blur
+    on:change
+    on:input
+    on:click
+    on:focus
+    on:keydown
+    on:keypress
+    on:keyup
+    on:mouseenter
+    on:mouseleave
+    on:mouseover
+    on:paste
+    type="search"
+    {placeholder}
+    {size}
+    {...$$restProps}
+    class={$$props.class}>
+    <svg
+      slot="left"
+      class={sizes[size]}
+      fill="currentColor"
+      viewBox="0 0 20 20"
+      xmlns="http://www.w3.org/2000/svg">
+      <path
+        fill-rule="evenodd"
+        d="M8 4a4 4 0 100 8 4 4 0 000-8zM2 8a6 6 0 1110.89 3.476l4.817 4.817a1 1 0 01-1.414 1.414l-4.816-4.816A6 6 0 012 8z"
+        clip-rule="evenodd" />
+    </svg>
+    <!-- We can use it here. See below. This will trigger right padding
+      <slot slot="right" />
+    -->
+  </Input>
+  <!-- This slot should be within Input as a slot='right'
+    Svelete has an issue with forwarded slots and even empty slot here will appear as existing slot in Input.
+    Due to that we need the below slot and Wrapper around
+  -->
+  {#if $$slots.default}
+    <div class="flex absolute inset-y-0 right-0 items-center pr-3 text-gray-500 dark:text-gray-400">
+      <slot />
+    </div>
+  {/if}
+</Wrapper>

package/forms/Search.svelte.d.ts

@@ -0,0 +1,34 @@
+import { SvelteComponentTyped } from "svelte";
+import type { FormSizeType } from '../types';
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        size?: FormSizeType | undefined;
+        placeholder?: string | undefined;
+    };
+    events: {
+        blur: FocusEvent;
+        change: Event;
+        input: Event;
+        click: MouseEvent;
+        focus: FocusEvent;
+        keydown: KeyboardEvent;
+        keypress: KeyboardEvent;
+        keyup: KeyboardEvent;
+        mouseenter: MouseEvent;
+        mouseleave: MouseEvent;
+        mouseover: MouseEvent;
+        paste: ClipboardEvent;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type SearchProps = typeof __propDef.props;
+export declare type SearchEvents = typeof __propDef.events;
+export declare type SearchSlots = typeof __propDef.slots;
+export default class Search extends SvelteComponentTyped<SearchProps, SearchEvents, SearchSlots> {
+}
+export {};

package/forms/Select.svelte

@@ -0,0 +1,25 @@
+<script>import classNames from 'classnames';
+export let items = [];
+export let value;
+export let placeholder = 'Choose option ...';
+export let underline = false;
+export let size = 'md';
+export let defaultClass = 'text-gray-900 bg-gray-50 border border-gray-300 rounded-lg focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-700 dark:border-gray-600 dark:placeholder-gray-400 dark:text-white dark:focus:ring-blue-500 dark:focus:border-blue-500';
+export let underlineClass = 'text-gray-500 bg-transparent border-0 border-b-2 border-gray-200 appearance-none dark:text-gray-400 dark:border-gray-700 focus:outline-none focus:ring-0 focus:border-gray-200 peer';
+const common = 'block w-full';
+const sizes = {
+    sm: 'text-sm p-2',
+    md: 'text-sm p-2.5',
+    lg: 'text-base py-3 px-4'
+};
+let selectClass;
+$: selectClass = classNames(common, underline ? underlineClass : defaultClass, sizes[size], underline && '!px-0', $$restProps.class);
+</script>
+
+<select {...$$restProps} bind:value class={selectClass} on:change on:input>
+  <option disabled selected value="">{placeholder}</option>
+
+  {#each items as { value, name }}
+    <option {value}>{name}</option>
+  {/each}
+</select>

package/forms/Select.svelte.d.ts

@@ -0,0 +1,27 @@
+import { SvelteComponentTyped } from "svelte";
+import type { SelectOptionType } from '../types';
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        items?: SelectOptionType[] | undefined;
+        value: string;
+        placeholder?: string | undefined;
+        underline?: boolean | undefined;
+        size?: "sm" | "md" | "lg" | undefined;
+        defaultClass?: string | undefined;
+        underlineClass?: string | undefined;
+    };
+    events: {
+        change: Event;
+        input: Event;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type SelectProps = typeof __propDef.props;
+export declare type SelectEvents = typeof __propDef.events;
+export declare type SelectSlots = typeof __propDef.slots;
+export default class Select extends SvelteComponentTyped<SelectProps, SelectEvents, SelectSlots> {
+}
+export {};

package/forms/SimpleSearch.svelte

@@ -0,0 +1,20 @@
+<script>import Search from './Search.svelte';
+import Button from '../buttons/Button.svelte';
+</script>
+
+<form class="flex gap-2" on:submit>
+  <Search size="md" {...$$restProps} />
+  <Button class="!p-2.5">
+    <svg
+      class="w-5 h-5"
+      fill="none"
+      stroke="currentColor"
+      viewBox="0 0 24 24"
+      xmlns="http://www.w3.org/2000/svg"
+      ><path
+        stroke-linecap="round"
+        stroke-linejoin="round"
+        stroke-width="2"
+        d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z" /></svg>
+  </Button>
+</form>

package/forms/SimpleSearch.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+    };
+    events: {
+        submit: SubmitEvent;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type SimpleSearchProps = typeof __propDef.props;
+export declare type SimpleSearchEvents = typeof __propDef.events;
+export declare type SimpleSearchSlots = typeof __propDef.slots;
+export default class SimpleSearch extends SvelteComponentTyped<SimpleSearchProps, SimpleSearchEvents, SimpleSearchSlots> {
+}
+export {};

package/forms/Textarea.svelte

@@ -0,0 +1,48 @@
+<script>import classNames from 'classnames';
+import { getContext } from 'svelte';
+import Wrapper from '../utils/Wrapper.svelte';
+const background = getContext('background');
+export let value = '';
+let wrapped;
+$: wrapped = $$slots.header || $$slots.footer;
+let wrapperClass;
+$: wrapperClass = classNames('w-full rounded-lg', background ? 'bg-white dark:bg-gray-800' : 'bg-gray-50 dark:bg-gray-700', 'text-gray-900 dark:placeholder-gray-400 dark:text-white ', 'border border-gray-200 dark:border-gray-600', $$props.class);
+let textareaClass;
+$: textareaClass = wrapped
+    ? classNames('block w-full', 'text-sm', 'border-0 px-0', 'bg-inherit dark:bg-inherit', 'focus:outline-none focus:ring-0')
+    : classNames(wrapperClass, 'p-2.5 text-sm', 'focus:ring-blue-500 focus:border-blue-500 dark:focus:ring-blue-500 dark:focus:border-blue-500');
+const headerClass = (header) => classNames(header ? 'border-b' : 'border-t', 'py-2 px-3 border-gray-200 dark:border-gray-600');
+let innerWrapperClass;
+$: innerWrapperClass = classNames('py-2 px-4 bg-white dark:bg-gray-800', $$slots.footer || 'rounded-b-lg', $$slots.header || 'rounded-t-lg');
+</script>
+
+<Wrapper show={wrapped} class={wrapperClass}>
+	{#if $$slots.header}
+		<div class={headerClass(true)}>
+			<slot name="header" />
+		</div>
+	{/if}
+	<Wrapper show={wrapped} class={innerWrapperClass}>
+		<textarea
+			bind:value
+			on:blur
+			on:change
+			on:click
+			on:focus
+			on:keydown
+			on:keypress
+			on:keyup
+			on:mouseenter
+			on:mouseleave
+			on:mouseover
+			on:paste
+			{...$$restProps}
+			class={textareaClass}
+		/>
+	</Wrapper>
+	{#if $$slots.footer}
+		<div class={headerClass(false)}>
+			<slot name="footer" />
+		</div>
+	{/if}
+</Wrapper>

package/forms/Textarea.svelte.d.ts

@@ -0,0 +1,32 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        value?: string | undefined;
+    };
+    events: {
+        blur: FocusEvent;
+        change: Event;
+        click: MouseEvent;
+        focus: FocusEvent;
+        keydown: KeyboardEvent;
+        keypress: KeyboardEvent;
+        keyup: KeyboardEvent;
+        mouseenter: MouseEvent;
+        mouseleave: MouseEvent;
+        mouseover: MouseEvent;
+        paste: ClipboardEvent;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        header: {};
+        footer: {};
+    };
+};
+export declare type TextareaProps = typeof __propDef.props;
+export declare type TextareaEvents = typeof __propDef.events;
+export declare type TextareaSlots = typeof __propDef.slots;
+export default class Textarea extends SvelteComponentTyped<TextareaProps, TextareaEvents, TextareaSlots> {
+}
+export {};

package/forms/Toggle.svelte

@@ -0,0 +1,32 @@
+<script>import { getContext } from 'svelte';
+import classNames from 'classnames';
+import Checkbox from './Checkbox.svelte';
+export let size = 'default';
+export let group = [];
+export let value = '';
+export let checked = false;
+// tinted if put in component having its own background
+let background = getContext('background');
+const common = "mr-3 bg-gray-200 rounded-full peer-focus:ring-4 peer-checked:after:translate-x-full peer-checked:after:border-white after:content-[''] after:absolute after:bg-white after:border-gray-300 after:border after:rounded-full after:transition-all";
+const colors = {
+    red: 'peer-focus:ring-red-300 dark:peer-focus:ring-red-800 peer-checked:bg-red-600',
+    green: 'peer-focus:ring-green-300 dark:peer-focus:ring-green-800 peer-checked:bg-green-600',
+    purple: 'peer-focus:ring-purple-300 dark:peer-focus:ring-purple-800 peer-checked:bg-purple-600',
+    yellow: 'peer-focus:ring-yellow-300 dark:peer-focus:ring-yellow-800 peer-checked:bg-yellow-400',
+    teal: 'peer-focus:ring-teal-300 dark:peer-focus:ring-teal-800 peer-checked:bg-teal-600',
+    orange: 'peer-focus:ring-orange-300 dark:peer-focus:ring-orange-800 peer-checked:bg-orange-500',
+    blue: 'peer-focus:ring-blue-300 dark:peer-focus:ring-blue-800 peer-checked:bg-blue-600'
+};
+const sizes = {
+    small: 'w-9 h-5 after:top-[2px] after:left-[2px] after:h-4 after:w-4',
+    default: 'w-11 h-6 after:top-0.5 after:left-[2px] after:h-5 after:w-5',
+    large: 'w-14 h-7 after:top-0.5 after:left-[4px]  after:h-6 after:w-6'
+};
+let divClass;
+$: divClass = classNames(common, background ? 'dark:bg-gray-600 dark:border-gray-500' : 'dark:bg-gray-700 dark:border-gray-600', colors[$$restProps.color ?? 'blue'], sizes[size], 'relative');
+</script>
+
+<Checkbox custom {...$$restProps} class={$$props.class} {value} bind:checked bind:group on:click on:change>
+  <span class={divClass} />
+  <slot />
+</Checkbox>

package/forms/Toggle.svelte.d.ts

@@ -0,0 +1,25 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        size?: "default" | "small" | "large" | undefined;
+        group?: string[] | undefined;
+        value?: string | undefined;
+        checked?: boolean | undefined;
+    };
+    events: {
+        click: MouseEvent;
+        change: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type ToggleProps = typeof __propDef.props;
+export declare type ToggleEvents = typeof __propDef.events;
+export declare type ToggleSlots = typeof __propDef.slots;
+export default class Toggle extends SvelteComponentTyped<ToggleProps, ToggleEvents, ToggleSlots> {
+}
+export {};