windmill-components 1.13.0

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

@@ -0,0 +1,22 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        initNew?: (() => Promise<void>) | undefined;
+        initEdit?: ((p: string) => Promise<void>) | undefined;
+    };
+    events: {
+        close: CustomEvent<any>;
+        refresh: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ResourceEditorProps = typeof __propDef.props;
+export declare type ResourceEditorEvents = typeof __propDef.events;
+export declare type ResourceEditorSlots = typeof __propDef.slots;
+export default class ResourceEditor extends SvelteComponentTyped<ResourceEditorProps, ResourceEditorEvents, ResourceEditorSlots> {
+    get initNew(): () => Promise<void>;
+    get initEdit(): (p: string) => Promise<void>;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        value: string | undefined;
+        resourceType: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ResourcePickerProps = typeof __propDef.props;
+export declare type ResourcePickerEvents = typeof __propDef.events;
+export declare type ResourcePickerSlots = typeof __propDef.slots;
+export default class ResourcePicker extends SvelteComponentTyped<ResourcePickerProps, ResourcePickerEvents, ResourcePickerSlots> {
+}
+export {};

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

@@ -0,0 +1,19 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        value: string | undefined;
+        notPickable?: boolean | undefined;
+    };
+    events: {
+        click: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ResourceTypePickerProps = typeof __propDef.props;
+export declare type ResourceTypePickerEvents = typeof __propDef.events;
+export declare type ResourceTypePickerSlots = typeof __propDef.slots;
+export default class ResourceTypePicker extends SvelteComponentTyped<ResourceTypePickerProps, ResourceTypePickerEvents, ResourceTypePickerSlots> {
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { SvelteComponentTyped } from "svelte";
+import type { Script, Flow } from '../../gen';
+declare const __propDef: {
+    props: {
+        runnable: Script | Flow | undefined;
+        runAction: (scheduledForStr: string | undefined, args: Record<string, any>) => void;
+        buttonText?: string | undefined;
+        schedulable?: boolean | undefined;
+        detailed?: boolean | undefined;
+        args?: Record<string, any> | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type RunFormProps = typeof __propDef.props;
+export declare type RunFormEvents = typeof __propDef.events;
+export declare type RunFormSlots = typeof __propDef.slots;
+export default class RunForm extends SvelteComponentTyped<RunFormProps, RunFormEvents, RunFormSlots> {
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { SvelteComponentTyped } from "svelte";
+import type { Schema } from '../../common';
+import Editor from './Editor.svelte';
+declare const __propDef: {
+    props: {
+        schema?: Schema | undefined;
+        getEditor?: (() => Editor) | undefined;
+        getSchema?: (() => Schema) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type SchemaEditorProps = typeof __propDef.props;
+export declare type SchemaEditorEvents = typeof __propDef.events;
+export declare type SchemaEditorSlots = typeof __propDef.slots;
+export default class SchemaEditor extends SvelteComponentTyped<SchemaEditorProps, SchemaEditorEvents, SchemaEditorSlots> {
+    get getEditor(): () => Editor;
+    get getSchema(): () => Schema;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import { SvelteComponentTyped } from "svelte";
+import type { Schema } from '../../common';
+declare const __propDef: {
+    props: {
+        inputTransform?: boolean | undefined;
+        schema: Schema;
+        args?: Record<string, any> | undefined;
+        isValid?: boolean | undefined;
+        editableSchema?: boolean | undefined;
+        setArgs?: ((nargs: Record<string, any>) => void) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type SchemaFormProps = typeof __propDef.props;
+export declare type SchemaFormEvents = typeof __propDef.events;
+export declare type SchemaFormSlots = typeof __propDef.slots;
+export default class SchemaForm extends SvelteComponentTyped<SchemaFormProps, SchemaFormEvents, SchemaFormSlots> {
+    get setArgs(): (nargs: Record<string, any>) => void;
+}
+export {};

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

@@ -0,0 +1,44 @@
+import { SvelteComponentTyped } from "svelte";
+import type { SchemaProperty } from '../../common';
+export declare const ARG_TYPES: readonly ["integer", "number", "string", "boolean", "object", "array"];
+export declare type ArgType = typeof ARG_TYPES[number];
+export interface ModalSchemaProperty {
+    selectedType?: string;
+    description: string;
+    name: string;
+    required: boolean;
+    format?: string;
+    pattern?: string;
+    enum_?: string[];
+    default?: any;
+    items?: {
+        type?: 'string' | 'number';
+    };
+}
+export declare function modalToSchema(schema: ModalSchemaProperty): SchemaProperty;
+export declare function schemaToModal(schema: SchemaProperty, name: string, required: boolean): ModalSchemaProperty;
+export declare const DEFAULT_PROPERTY: ModalSchemaProperty;
+declare const __propDef: {
+    props: {
+        property?: ModalSchemaProperty | undefined;
+        error?: string | undefined;
+        editing?: boolean | undefined;
+        oldArgName: string | undefined;
+        openModal?: (() => void) | undefined;
+        closeModal?: (() => void) | undefined;
+    };
+    events: {
+        save: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type SchemaModalProps = typeof __propDef.props;
+export declare type SchemaModalEvents = typeof __propDef.events;
+export declare type SchemaModalSlots = typeof __propDef.slots;
+export default class SchemaModal extends SvelteComponentTyped<SchemaModalProps, SchemaModalEvents, SchemaModalSlots> {
+    get openModal(): () => void;
+    get closeModal(): () => void;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+import type { Schema } from '../../common';
+declare const __propDef: {
+    props: {
+        schema?: Schema | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type SchemaViewerProps = typeof __propDef.props;
+export declare type SchemaViewerEvents = typeof __propDef.events;
+export declare type SchemaViewerSlots = typeof __propDef.slots;
+export default class SchemaViewer extends SvelteComponentTyped<SchemaViewerProps, SchemaViewerEvents, SchemaViewerSlots> {
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { SvelteComponentTyped } from "svelte";
+import { type Script } from '../../gen';
+declare const __propDef: {
+    props: {
+        script: Script;
+        initialPath?: string | undefined;
+        setCode?: ((script: Script) => void) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ScriptBuilderProps = typeof __propDef.props;
+export declare type ScriptBuilderEvents = typeof __propDef.events;
+export declare type ScriptBuilderSlots = typeof __propDef.slots;
+export default class ScriptBuilder extends SvelteComponentTyped<ScriptBuilderProps, ScriptBuilderEvents, ScriptBuilderSlots> {
+    get setCode(): (script: Script) => void;
+}
+export {};

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

@@ -0,0 +1,28 @@
+import { SvelteComponentTyped } from "svelte";
+import type { Schema } from '../../common';
+import Editor from './Editor.svelte';
+import type { Preview } from '../../gen/models/Preview';
+declare const __propDef: {
+    props: {
+        schema?: Schema | undefined;
+        code: string;
+        path: string | undefined;
+        lang: Preview.language;
+        viewPreview?: boolean | undefined;
+        previewTab?: "input" | "output" | "logs" | "history" | "last_save" | undefined;
+        getEditor?: (() => Editor) | undefined;
+        runPreview?: (() => Promise<void>) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ScriptEditorProps = typeof __propDef.props;
+export declare type ScriptEditorEvents = typeof __propDef.events;
+export declare type ScriptEditorSlots = typeof __propDef.slots;
+export default class ScriptEditor extends SvelteComponentTyped<ScriptEditorProps, ScriptEditorEvents, ScriptEditorSlots> {
+    get getEditor(): () => Editor;
+    get runPreview(): () => Promise<void>;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        scriptPath?: string | undefined;
+        allowFlow?: boolean | undefined;
+        allowHub?: boolean | undefined;
+        itemKind?: "script" | "flow" | "hub" | undefined;
+    };
+    events: {
+        select: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ScriptPickerProps = typeof __propDef.props;
+export declare type ScriptPickerEvents = typeof __propDef.events;
+export declare type ScriptPickerSlots = typeof __propDef.slots;
+export default class ScriptPicker extends SvelteComponentTyped<ScriptPickerProps, ScriptPickerEvents, ScriptPickerSlots> {
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { SvelteComponentTyped } from "svelte";
+import type { Schema } from '../../common';
+declare const __propDef: {
+    props: {
+        schema: Schema;
+        summary: string;
+        description: string | undefined;
+        synchronizedHeader?: boolean | undefined;
+        setSchema?: ((newSchema: Schema) => void) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ScriptSchemaProps = typeof __propDef.props;
+export declare type ScriptSchemaEvents = typeof __propDef.events;
+export declare type ScriptSchemaSlots = typeof __propDef.slots;
+export default class ScriptSchema extends SvelteComponentTyped<ScriptSchemaProps, ScriptSchemaEvents, ScriptSchemaSlots> {
+    get setSchema(): (newSchema: Schema) => void;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        kind: 'script' | 'group_' | 'resource' | 'schedule' | 'variable' | 'flow';
+        path?: string | undefined;
+        openModal?: ((newPath?: string) => Promise<void>) | undefined;
+    };
+    events: {
+        change: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ShareModalProps = typeof __propDef.props;
+export declare type ShareModalEvents = typeof __propDef.events;
+export declare type ShareModalSlots = typeof __propDef.slots;
+export default class ShareModal extends SvelteComponentTyped<ShareModalProps, ShareModalEvents, ShareModalSlots> {
+    get openModal(): (newPath?: string | undefined) => Promise<void>;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        extraPerms?: Record<string, boolean> | undefined;
+        canWrite: boolean;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type SharedBadgeProps = typeof __propDef.props;
+export declare type SharedBadgeEvents = typeof __propDef.events;
+export declare type SharedBadgeSlots = typeof __propDef.slots;
+export default class SharedBadge extends SvelteComponentTyped<SharedBadgeProps, SharedBadgeEvents, SharedBadgeSlots> {
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        pattern: string | undefined;
+        enum_: string[] | undefined;
+        format: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type StringTypeNarrowingProps = typeof __propDef.props;
+export declare type StringTypeNarrowingEvents = typeof __propDef.events;
+export declare type StringTypeNarrowingSlots = typeof __propDef.slots;
+export default class StringTypeNarrowing extends SvelteComponentTyped<StringTypeNarrowingProps, StringTypeNarrowingEvents, StringTypeNarrowingSlots> {
+}
+export {};

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

@@ -0,0 +1,31 @@
+/** @typedef {typeof __propDef.props}  SwitchProps */
+/** @typedef {typeof __propDef.events}  SwitchEvents */
+/** @typedef {typeof __propDef.slots}  SwitchSlots */
+export default class Switch extends SvelteComponentTyped<{
+    [x: string]: any;
+    checked?: boolean | undefined;
+    label?: string | undefined;
+    horizontal?: boolean | undefined;
+    textFormat?: string | undefined;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}> {
+}
+export type SwitchProps = typeof __propDef.props;
+export type SwitchEvents = typeof __propDef.events;
+export type SwitchSlots = typeof __propDef.slots;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        checked?: boolean | undefined;
+        label?: string | undefined;
+        horizontal?: boolean | undefined;
+        textFormat?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export {};

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

@@ -0,0 +1,25 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        paginated?: boolean | undefined;
+        currentPage?: number | undefined;
+        showNext?: boolean | undefined;
+    };
+    events: {
+        next: CustomEvent<any>;
+        previous: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        'header-row': {};
+        body: {};
+    };
+};
+export declare type TableCustomProps = typeof __propDef.props;
+export declare type TableCustomEvents = typeof __propDef.events;
+export declare type TableCustomSlots = typeof __propDef.slots;
+export default class TableCustom extends SvelteComponentTyped<TableCustomProps, TableCustomEvents, TableCustomSlots> {
+}
+export {};

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

@@ -0,0 +1,24 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        headers: string[] | undefined;
+        data: any[] | undefined;
+        keys: string[];
+        defaultText?: string | undefined;
+        paginated?: boolean | undefined;
+        twTextSize?: string | undefined;
+    };
+    events: {
+        next: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type TableSimpleProps = typeof __propDef.props;
+export declare type TableSimpleEvents = typeof __propDef.events;
+export declare type TableSimpleSlots = typeof __propDef.slots;
+export default class TableSimple extends SvelteComponentTyped<TableSimpleProps, TableSimpleEvents, TableSimpleSlots> {
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        tabs: [string, string][];
+        dflt?: number | undefined;
+        tab?: string | undefined;
+    };
+    events: {
+        update: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type TabsProps = typeof __propDef.props;
+export declare type TabsEvents = typeof __propDef.events;
+export declare type TabsSlots = typeof __propDef.slots;
+export default class Tabs extends SvelteComponentTyped<TabsProps, TabsEvents, TabsSlots> {
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        position?: ("above" | "below") | undefined;
+        direction?: ("default" | "left") | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type TooltipProps = typeof __propDef.props;
+export declare type TooltipEvents = typeof __propDef.events;
+export declare type TooltipSlots = typeof __propDef.slots;
+export default class Tooltip extends SvelteComponentTyped<TooltipProps, TooltipEvents, TooltipSlots> {
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        initNew?: (() => void) | undefined;
+        editVariable?: ((path: string) => Promise<void>) | undefined;
+    };
+    events: {
+        create: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type VariableEditorProps = typeof __propDef.props;
+export declare type VariableEditorEvents = typeof __propDef.events;
+export declare type VariableEditorSlots = typeof __propDef.slots;
+export default class VariableEditor extends SvelteComponentTyped<VariableEditorProps, VariableEditorEvents, VariableEditorSlots> {
+    get initNew(): () => void;
+    get editVariable(): (path: string) => Promise<void>;
+}
+export {};

package/lib/components/icons/DbIcon.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        height?: string | undefined;
+        width?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type DbIconProps = typeof __propDef.props;
+export declare type DbIconEvents = typeof __propDef.events;
+export declare type DbIconSlots = typeof __propDef.slots;
+export default class DbIcon extends SvelteComponentTyped<DbIconProps, DbIconEvents, DbIconSlots> {
+}
+export {};

package/lib/components/icons/Mail.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        height?: string | undefined;
+        width?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type MailProps = typeof __propDef.props;
+export declare type MailEvents = typeof __propDef.events;
+export declare type MailSlots = typeof __propDef.slots;
+export default class Mail extends SvelteComponentTyped<MailProps, MailEvents, MailSlots> {
+}
+export {};

package/lib/components/icons/Mysql.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        height?: string | undefined;
+        width?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type MysqlProps = typeof __propDef.props;
+export declare type MysqlEvents = typeof __propDef.events;
+export declare type MysqlSlots = typeof __propDef.slots;
+export default class Mysql extends SvelteComponentTyped<MysqlProps, MysqlEvents, MysqlSlots> {
+}
+export {};

package/lib/components/icons/PostgresIcon.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        height?: string | undefined;
+        width?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type PostgresIconProps = typeof __propDef.props;
+export declare type PostgresIconEvents = typeof __propDef.events;
+export declare type PostgresIconSlots = typeof __propDef.slots;
+export default class PostgresIcon extends SvelteComponentTyped<PostgresIconProps, PostgresIconEvents, PostgresIconSlots> {
+}
+export {};

package/lib/components/icons/Slack.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        height?: string | undefined;
+        width?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type SlackProps = typeof __propDef.props;
+export declare type SlackEvents = typeof __propDef.events;
+export declare type SlackSlots = typeof __propDef.slots;
+export default class Slack extends SvelteComponentTyped<SlackProps, SlackEvents, SlackSlots> {
+}
+export {};