windmill-components 1.13.0

package/lib/components/Badge.svelte.d.ts

@@ -0,0 +1,20 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        twBgColor?: string | undefined;
+        twTextColor?: string | undefined;
+        tooltip?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type BadgeProps = typeof __propDef.props;
+export declare type BadgeEvents = typeof __propDef.events;
+export declare type BadgeSlots = typeof __propDef.slots;
+export default class Badge extends SvelteComponentTyped<BadgeProps, BadgeEvents, BadgeSlots> {
+}
+export {};

package/lib/components/Button.svelte.d.ts

@@ -0,0 +1,23 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        category: 'delete' | 'list' | 'run' | 'add' | 'edit' | 'archive' | 'share';
+        disabled?: boolean | undefined;
+    };
+    events: {
+        click: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        text: {};
+        'text-gray-500': {};
+    };
+};
+export declare type ButtonProps = typeof __propDef.props;
+export declare type ButtonEvents = typeof __propDef.events;
+export declare type ButtonSlots = typeof __propDef.slots;
+export default class Button extends SvelteComponentTyped<ButtonProps, ButtonEvents, ButtonSlots> {
+}
+export {};

package/lib/components/ButtonAndDropdown.svelte.d.ts

@@ -0,0 +1,23 @@
+import { SvelteComponentTyped } from "svelte";
+import type { DropdownItem } from '../../utils';
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        dropdownItems?: DropdownItem[] | undefined;
+    };
+    events: {
+        clickMain: CustomEvent<any>;
+        clickDropdown: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        name: {};
+    };
+};
+export declare type ButtonAndDropdownProps = typeof __propDef.props;
+export declare type ButtonAndDropdownEvents = typeof __propDef.events;
+export declare type ButtonAndDropdownSlots = typeof __propDef.slots;
+export default class ButtonAndDropdown extends SvelteComponentTyped<ButtonAndDropdownProps, ButtonAndDropdownEvents, ButtonAndDropdownSlots> {
+}
+export {};

package/lib/components/CenteredPage.svelte.d.ts

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

package/lib/components/ChevronButton.svelte.d.ts

@@ -0,0 +1,19 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        text: string;
+        viewOptions?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type ChevronButtonProps = typeof __propDef.props;
+export declare type ChevronButtonEvents = typeof __propDef.events;
+export declare type ChevronButtonSlots = typeof __propDef.slots;
+export default class ChevronButton extends SvelteComponentTyped<ChevronButtonProps, ChevronButtonEvents, ChevronButtonSlots> {
+}
+export {};

package/lib/components/DisplayResult.svelte.d.ts

@@ -0,0 +1,16 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        result: any;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type DisplayResultProps = typeof __propDef.props;
+export declare type DisplayResultEvents = typeof __propDef.events;
+export declare type DisplayResultSlots = typeof __propDef.slots;
+export default class DisplayResult extends SvelteComponentTyped<DisplayResultProps, DisplayResultEvents, DisplayResultSlots> {
+}
+export {};

package/lib/components/Dropdown.svelte.d.ts

@@ -0,0 +1,22 @@
+import { SvelteComponentTyped } from "svelte";
+import type { DropdownItem } from '../../utils';
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        dropdownItems: DropdownItem[];
+        name?: string | undefined;
+        relative?: boolean | undefined;
+    };
+    events: {
+        click: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type DropdownProps = typeof __propDef.props;
+export declare type DropdownEvents = typeof __propDef.events;
+export declare type DropdownSlots = typeof __propDef.slots;
+export default class Dropdown extends SvelteComponentTyped<DropdownProps, DropdownEvents, DropdownSlots> {
+}
+export {};

package/lib/components/Editor.svelte.d.ts

@@ -0,0 +1,38 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        deno?: boolean | undefined;
+        lang?: string | undefined;
+        code: string;
+        hash?: string | undefined;
+        cmdEnterAction?: (() => void) | undefined;
+        formatAction?: (() => void) | undefined;
+        automaticLayout?: boolean | undefined;
+        websocketAlive?: {
+            pyright: boolean;
+            black: boolean;
+            deno: boolean;
+        } | undefined;
+        getCode?: (() => string) | undefined;
+        insertAtCursor?: ((code: string) => void) | undefined;
+        insertAtBeginning?: ((code: string) => void) | undefined;
+        setCode?: ((ncode: string) => void) | undefined;
+        reloadWebsocket?: (() => Promise<void>) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type EditorProps = typeof __propDef.props;
+export declare type EditorEvents = typeof __propDef.events;
+export declare type EditorSlots = typeof __propDef.slots;
+export default class Editor extends SvelteComponentTyped<EditorProps, EditorEvents, EditorSlots> {
+    get getCode(): () => string;
+    get insertAtCursor(): (code: string) => void;
+    get insertAtBeginning(): (code: string) => void;
+    get setCode(): (ncode: string) => void;
+    get reloadWebsocket(): () => Promise<void>;
+}
+export {};

package/lib/components/FieldHeader.svelte.d.ts

@@ -0,0 +1,23 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        label: string;
+        format?: string | undefined;
+        contentEncoding?: string | undefined;
+        type?: string | undefined;
+        required?: boolean | undefined;
+        itemsType?: {
+            type?: "string" | "number" | undefined;
+        } | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type FieldHeaderProps = typeof __propDef.props;
+export declare type FieldHeaderEvents = typeof __propDef.events;
+export declare type FieldHeaderSlots = typeof __propDef.slots;
+export default class FieldHeader extends SvelteComponentTyped<FieldHeaderProps, FieldHeaderEvents, FieldHeaderSlots> {
+}
+export {};

package/lib/components/FlowBuilder.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponentTyped } from "svelte";
+import { type Flow } from '../../gen';
+declare const __propDef: {
+    props: {
+        flow: Flow;
+        initialPath?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type FlowBuilderProps = typeof __propDef.props;
+export declare type FlowBuilderEvents = typeof __propDef.events;
+export declare type FlowBuilderSlots = typeof __propDef.slots;
+export default class FlowBuilder extends SvelteComponentTyped<FlowBuilderProps, FlowBuilderEvents, FlowBuilderSlots> {
+}
+export {};

package/lib/components/FlowEditor.svelte.d.ts

@@ -0,0 +1,19 @@
+import { SvelteComponentTyped } from "svelte";
+import { type Flow } from '../../gen';
+declare const __propDef: {
+    props: {
+        flow: Flow;
+        loadSchemas?: (() => Promise<void>) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type FlowEditorProps = typeof __propDef.props;
+export declare type FlowEditorEvents = typeof __propDef.events;
+export declare type FlowEditorSlots = typeof __propDef.slots;
+export default class FlowEditor extends SvelteComponentTyped<FlowEditorProps, FlowEditorEvents, FlowEditorSlots> {
+    get loadSchemas(): () => Promise<void>;
+}
+export {};

package/lib/components/FlowPreview.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+import { type Flow } from '../../gen';
+import type { Schema } from '../../common';
+declare const __propDef: {
+    props: {
+        i: number;
+        flow: Flow;
+        schemas?: Schema[] | undefined;
+        args?: Record<string, any> | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type FlowPreviewProps = typeof __propDef.props;
+export declare type FlowPreviewEvents = typeof __propDef.events;
+export declare type FlowPreviewSlots = typeof __propDef.slots;
+export default class FlowPreview extends SvelteComponentTyped<FlowPreviewProps, FlowPreviewEvents, FlowPreviewSlots> {
+}
+export {};

package/lib/components/FlowStatusViewer.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponentTyped } from "svelte";
+import { CompletedJob, QueuedJob } from '../../gen';
+declare const __propDef: {
+    props: {
+        job: QueuedJob | CompletedJob;
+        jobs: (CompletedJob | undefined)[];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type FlowStatusViewerProps = typeof __propDef.props;
+export declare type FlowStatusViewerEvents = typeof __propDef.events;
+export declare type FlowStatusViewerSlots = typeof __propDef.slots;
+export default class FlowStatusViewer extends SvelteComponentTyped<FlowStatusViewerProps, FlowStatusViewerEvents, FlowStatusViewerSlots> {
+}
+export {};

package/lib/components/GroupModal.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        openModal?: ((newName: string) => void) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type GroupModalProps = typeof __propDef.props;
+export declare type GroupModalEvents = typeof __propDef.events;
+export declare type GroupModalSlots = typeof __propDef.slots;
+export default class GroupModal extends SvelteComponentTyped<GroupModalProps, GroupModalEvents, GroupModalSlots> {
+    get openModal(): (newName: string) => void;
+}
+export {};

package/lib/components/IconedResourceType.svelte.d.ts

@@ -0,0 +1,19 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        name: string;
+        after?: boolean | undefined;
+        height?: string | undefined;
+        width?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type IconedResourceTypeProps = typeof __propDef.props;
+export declare type IconedResourceTypeEvents = typeof __propDef.events;
+export declare type IconedResourceTypeSlots = typeof __propDef.slots;
+export default class IconedResourceType extends SvelteComponentTyped<IconedResourceTypeProps, IconedResourceTypeEvents, IconedResourceTypeSlots> {
+}
+export {};

package/lib/components/InviteGlobalUser.svelte.d.ts

@@ -0,0 +1,19 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        openModal?: (() => void) | undefined;
+    };
+    events: {
+        new: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type InviteGlobalUserProps = typeof __propDef.props;
+export declare type InviteGlobalUserEvents = typeof __propDef.events;
+export declare type InviteGlobalUserSlots = typeof __propDef.slots;
+export default class InviteGlobalUser extends SvelteComponentTyped<InviteGlobalUserProps, InviteGlobalUserEvents, InviteGlobalUserSlots> {
+    get openModal(): () => void;
+}
+export {};

package/lib/components/InviteUser.svelte.d.ts

@@ -0,0 +1,19 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        openModal?: (() => void) | undefined;
+    };
+    events: {
+        new: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type InviteUserProps = typeof __propDef.props;
+export declare type InviteUserEvents = typeof __propDef.events;
+export declare type InviteUserSlots = typeof __propDef.slots;
+export default class InviteUser extends SvelteComponentTyped<InviteUserProps, InviteUserEvents, InviteUserSlots> {
+    get openModal(): () => void;
+}
+export {};

package/lib/components/ItemPicker.svelte.d.ts

@@ -0,0 +1,24 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        pickCallback: (path: string, f: string) => void;
+        loadItems: () => Promise<Record<string, any>[]>;
+        extraField: string;
+        itemName: string;
+        closeOnClick?: boolean | undefined;
+        openModal?: (() => void) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        submission: {};
+    };
+};
+export declare type ItemPickerProps = typeof __propDef.props;
+export declare type ItemPickerEvents = typeof __propDef.events;
+export declare type ItemPickerSlots = typeof __propDef.slots;
+export default class ItemPicker extends SvelteComponentTyped<ItemPickerProps, ItemPickerEvents, ItemPickerSlots> {
+    get openModal(): () => void;
+}
+export {};

package/lib/components/JobStatus.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+import type { CompletedJob, QueuedJob } from '../../gen';
+declare const __propDef: {
+    props: {
+        job: QueuedJob | CompletedJob | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type JobStatusProps = typeof __propDef.props;
+export declare type JobStatusEvents = typeof __propDef.events;
+export declare type JobStatusSlots = typeof __propDef.slots;
+export default class JobStatus extends SvelteComponentTyped<JobStatusProps, JobStatusEvents, JobStatusSlots> {
+}
+export {};

package/lib/components/Modal.svelte.d.ts

@@ -0,0 +1,28 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        open?: boolean | undefined;
+        z?: string | undefined;
+        closeModal?: (() => void) | undefined;
+        openModal?: (() => void) | undefined;
+    };
+    events: {
+        close: CustomEvent<any>;
+        open: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        title: {};
+        content: {};
+        submission: {};
+    };
+};
+export declare type ModalProps = typeof __propDef.props;
+export declare type ModalEvents = typeof __propDef.events;
+export declare type ModalSlots = typeof __propDef.slots;
+export default class Modal extends SvelteComponentTyped<ModalProps, ModalEvents, ModalSlots> {
+    get closeModal(): () => void;
+    get openModal(): () => void;
+}
+export {};

package/lib/components/ModuleStep.svelte.d.ts

@@ -0,0 +1,26 @@
+import { SvelteComponentTyped } from "svelte";
+import type { Schema } from '../../common';
+import type { Flow, FlowModule } from '../../gen';
+import SchemaForm from './SchemaForm.svelte';
+declare const __propDef: {
+    props: {
+        flow: Flow;
+        i: number;
+        mod: FlowModule;
+        args?: Record<string, any> | undefined;
+        schemas?: Schema[] | undefined;
+        schemaForms?: (SchemaForm | undefined)[] | undefined;
+        loadSchema?: (() => Promise<void>) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ModuleStepProps = typeof __propDef.props;
+export declare type ModuleStepEvents = typeof __propDef.events;
+export declare type ModuleStepSlots = typeof __propDef.slots;
+export default class ModuleStep extends SvelteComponentTyped<ModuleStepProps, ModuleStepEvents, ModuleStepSlots> {
+    get loadSchema(): () => Promise<void>;
+}
+export {};

package/lib/components/Multiselect.svelte.d.ts

@@ -0,0 +1,33 @@
+/** @typedef {typeof __propDef.props}  MultiselectProps */
+/** @typedef {typeof __propDef.events}  MultiselectEvents */
+/** @typedef {typeof __propDef.slots}  MultiselectSlots */
+export default class Multiselect extends SvelteComponentTyped<{
+    value?: any[] | undefined;
+    id?: string | undefined;
+    readonly?: boolean | undefined;
+    placeholder?: string | undefined;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}> {
+}
+export type MultiselectProps = typeof __propDef.props;
+export type MultiselectEvents = typeof __propDef.events;
+export type MultiselectSlots = typeof __propDef.slots;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        value?: any[] | undefined;
+        id?: string | undefined;
+        readonly?: boolean | undefined;
+        placeholder?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export {};

package/lib/components/ObjectResourceInput.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        format: string;
+        value: any;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ObjectResourceInputProps = typeof __propDef.props;
+export declare type ObjectResourceInputEvents = typeof __propDef.events;
+export declare type ObjectResourceInputSlots = typeof __propDef.slots;
+export default class ObjectResourceInput extends SvelteComponentTyped<ObjectResourceInputProps, ObjectResourceInputEvents, ObjectResourceInputSlots> {
+}
+export {};

package/lib/components/ObjectTypeNarrowing.svelte.d.ts

@@ -0,0 +1,16 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        format: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ObjectTypeNarrowingProps = typeof __propDef.props;
+export declare type ObjectTypeNarrowingEvents = typeof __propDef.events;
+export declare type ObjectTypeNarrowingSlots = typeof __propDef.slots;
+export default class ObjectTypeNarrowing extends SvelteComponentTyped<ObjectTypeNarrowingProps, ObjectTypeNarrowingEvents, ObjectTypeNarrowingSlots> {
+}
+export {};

package/lib/components/PageHeader.svelte.d.ts

@@ -0,0 +1,20 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        title: string;
+        tooltip?: string | undefined;
+        primary?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type PageHeaderProps = typeof __propDef.props;
+export declare type PageHeaderEvents = typeof __propDef.events;
+export declare type PageHeaderSlots = typeof __propDef.slots;
+export default class PageHeader extends SvelteComponentTyped<PageHeaderProps, PageHeaderEvents, PageHeaderSlots> {
+}
+export {};

package/lib/components/Password.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        password: string;
+        label?: string | undefined;
+        placeholder?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type PasswordProps = typeof __propDef.props;
+export declare type PasswordEvents = typeof __propDef.events;
+export declare type PasswordSlots = typeof __propDef.slots;
+export default class Password extends SvelteComponentTyped<PasswordProps, PasswordEvents, PasswordSlots> {
+}
+export {};

package/lib/components/Path.svelte.d.ts

@@ -0,0 +1,26 @@
+import { SvelteComponentTyped } from "svelte";
+import { type Meta } from '../../common';
+declare const __propDef: {
+    props: {
+        meta?: Meta | undefined;
+        namePlaceholder?: string | undefined;
+        initialPath: string;
+        path?: string | undefined;
+        getPath?: (() => string) | undefined;
+        reset?: (() => Promise<void>) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        ownerToolkit: {};
+    };
+};
+export declare type PathProps = typeof __propDef.props;
+export declare type PathEvents = typeof __propDef.events;
+export declare type PathSlots = typeof __propDef.slots;
+export default class Path extends SvelteComponentTyped<PathProps, PathEvents, PathSlots> {
+    get getPath(): () => string;
+    get reset(): () => Promise<void>;
+}
+export {};

package/lib/components/RadioButton.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        label?: string | undefined;
+        options: [string, any][];
+        value: any;
+        small?: boolean | undefined;
+    };
+    events: {
+        change: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type RadioButtonProps = typeof __propDef.props;
+export declare type RadioButtonEvents = typeof __propDef.events;
+export declare type RadioButtonSlots = typeof __propDef.slots;
+export default class RadioButton extends SvelteComponentTyped<RadioButtonProps, RadioButtonEvents, RadioButtonSlots> {
+}
+export {};

package/lib/components/Required.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        required: boolean;
+        detail?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type RequiredProps = typeof __propDef.props;
+export declare type RequiredEvents = typeof __propDef.events;
+export declare type RequiredSlots = typeof __propDef.slots;
+export default class Required extends SvelteComponentTyped<RequiredProps, RequiredEvents, RequiredSlots> {
+}
+export {};