@mastra/playground-ui 1.0.0-alpha.8 → 1.0.0

package/dist/components/dynamic-form/default-field-map.d.ts

@@ -0,0 +1,16 @@
+import { FieldProps } from './schema';
+
+export declare function getDefaultFieldMap(): {
+    STRING: (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+    NUMBER: (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+    BOOLEAN: (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+    DATE: (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+    ENUM: (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+    ARRAY: (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+    RECORD: (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+    OBJECT: (props: FieldProps) => import("react/jsx-runtime").JSX.Element | null;
+    UNION: (props: FieldProps) => import("react/jsx-runtime").JSX.Element | null;
+    CREATABLE: (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+    SELECT: (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+    MULTI_SELECT: (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/components/dynamic-form/fields/array-field.d.ts

@@ -0,0 +1,17 @@
+import { Control } from 'react-hook-form';
+import * as React from 'react';
+interface ArrayFieldProps {
+    name: string;
+    control: Control<any>;
+    renderField: (props: {
+        fieldName: string;
+        index: number;
+    }) => React.ReactNode;
+    handleFieldChange?: (props: {
+        key: string;
+        value: any[];
+    }) => void;
+    isStringField?: boolean;
+}
+export declare function ArrayField({ name, control, renderField, isStringField }: ArrayFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dynamic-form/fields/boolean-field.d.ts

@@ -0,0 +1,12 @@
+import { Control } from 'react-hook-form';
+
+interface BooleanFieldProps {
+    name: string;
+    control: Control<any>;
+    handleFieldChange?: (props: {
+        key: string;
+        value: boolean;
+    }) => void;
+}
+export declare function BooleanField({ name, control, handleFieldChange }: BooleanFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dynamic-form/fields/creatable-field.d.ts

@@ -0,0 +1,17 @@
+import { Control } from 'react-hook-form';
+
+interface CreatableFieldProps {
+    name: string;
+    control: Control<any>;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    handleFieldChange?: (props: {
+        key: string;
+        value: string[];
+    }) => void;
+    placeholder?: string;
+}
+export declare function CreatableField({ name, control, options, handleFieldChange, placeholder }: CreatableFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dynamic-form/fields/date-field.d.ts

@@ -0,0 +1,12 @@
+import { Control } from 'react-hook-form';
+
+interface DateFieldProps {
+    name: string;
+    control: Control<any>;
+    handleFieldChange?: (props: {
+        key: string;
+        value: string | Date | null | undefined;
+    }) => void;
+}
+export declare function DateField({ name, control, handleFieldChange }: DateFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dynamic-form/fields/enum-field.d.ts

@@ -0,0 +1,16 @@
+import { Control } from 'react-hook-form';
+
+interface EnumFieldProps {
+    name: string;
+    control: Control<any>;
+    options: {
+        label: string;
+        value: string;
+    }[];
+    handleFieldChange?: (props: {
+        key: string;
+        value: string;
+    }) => void;
+}
+export declare function EnumField({ name, control, options, handleFieldChange }: EnumFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dynamic-form/fields/index.d.ts

@@ -0,0 +1,10 @@
+export { ArrayField } from './array-field';
+export { BooleanField } from './boolean-field';
+export { CreatableField } from './creatable-field';
+export { DateField } from './date-field';
+export { EnumField } from './enum-field';
+export { StringField } from './string-field';
+export { UnionField } from './union-field';
+export { ObjectField } from './object-field';
+export { NumberField } from './number-field';
+export { RecordField } from './record-field';

package/dist/components/dynamic-form/fields/number-field.d.ts

@@ -0,0 +1,12 @@
+import { Control } from 'react-hook-form';
+
+interface NumberFieldProps {
+    name: string;
+    control: Control<any>;
+    handleFieldChange?: (props: {
+        key: string;
+        value: number;
+    }) => void;
+}
+export declare function NumberField({ name, control, handleFieldChange }: NumberFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dynamic-form/fields/object-field.d.ts

@@ -0,0 +1,27 @@
+import { ZodSchema } from 'zod';
+import * as React from 'react';
+interface ObjectFieldProps {
+    renderDynamicForm: (props: {
+        schema: ZodSchema;
+        handleFieldChange: (field: string, value: any) => void;
+        control: any;
+        formValues: Record<string, any>;
+        errors: Record<string, any>;
+        parentField: string;
+        action?: any;
+        isOptional?: boolean;
+        depth?: number;
+    }) => React.ReactNode;
+    schema: ZodSchema;
+    handleFieldChange: (field: string, value: any) => void;
+    control: any;
+    formValues: Record<string, any>;
+    errors: Record<string, any>;
+    parentField: string;
+    action?: any;
+    isArray?: boolean;
+    isOptional?: boolean;
+    depth?: number;
+}
+export declare function ObjectField({ renderDynamicForm, schema, handleFieldChange, control, formValues, errors, parentField, action, isArray, isOptional, depth, }: ObjectFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dynamic-form/fields/record-field.d.ts

@@ -0,0 +1,14 @@
+import { Control } from 'react-hook-form';
+import { ZodSchema } from 'zod';
+
+interface RecordFieldProps {
+    name: string;
+    control: Control<any>;
+    innerSchema?: ZodSchema;
+    handleFieldChange?: (props: {
+        key: string;
+        value: Record<string, any>;
+    }) => void;
+}
+export declare function RecordField({ name, control, handleFieldChange }: RecordFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dynamic-form/fields/string-field.d.ts

@@ -0,0 +1,14 @@
+import { Control } from 'react-hook-form';
+
+interface StringFieldProps {
+    name: string;
+    control: Control<any>;
+    handleFieldChange?: (props: {
+        key: string;
+        value: any;
+    }) => void;
+    isMultiline?: boolean;
+    placeholder?: string;
+}
+export declare function StringField({ name, control, handleFieldChange, isMultiline, placeholder }: StringFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dynamic-form/fields/union-field.d.ts

@@ -0,0 +1,28 @@
+import { ZodUnion } from 'zod';
+import * as React from 'react';
+interface UnionComponentProps {
+    renderDynamicForm: (props: {
+        schema: ZodUnion<any>;
+        handleFieldChange: (field: string, value: any) => void;
+        control: any;
+        formValues: Record<string, any>;
+        errors: Record<string, any>;
+        parentField: string;
+        action?: any;
+        isOptional?: boolean;
+        isNullable?: boolean;
+        depth?: number;
+    }) => React.ReactNode;
+    schema: ZodUnion<any>;
+    handleFieldChange: (field: string, value: any) => void;
+    control: any;
+    formValues: Record<string, any>;
+    errors: Record<string, any>;
+    parentField: string;
+    action?: any;
+    isOptional?: boolean;
+    isNullable?: boolean;
+    depth?: number;
+}
+export declare function UnionField({ renderDynamicForm, schema, handleFieldChange, control, formValues, errors, parentField, action, isOptional, isNullable, depth, }: UnionComponentProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/dynamic-form/index.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+interface DynamicFormProps<T extends z.ZodSchema> {
+    schema: T;
+    onSubmit: (values: z.infer<T>) => void | Promise<void>;
+    defaultValues?: z.infer<T>;
+    isSubmitLoading?: boolean;
+    submitButtonLabel?: string;
+}
+export declare function DynamicForm<T extends z.ZodSchema>({ schema, onSubmit, defaultValues, isSubmitLoading, submitButtonLabel, }: DynamicFormProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dynamic-form/resolvers/index.d.ts

@@ -0,0 +1,4 @@
+import { Resolver } from 'react-hook-form';
+import { z } from 'zod';
+
+export declare const customZodUnionResolver: (schemaUnion: z.ZodTypeAny, discriminator: string) => Resolver<any>;

package/dist/components/dynamic-form/schema-resolver.d.ts

@@ -0,0 +1,21 @@
+import { Control, FieldErrors } from 'react-hook-form';
+import { z } from 'zod';
+
+interface ResolveSchemaProps {
+    schema: z.ZodSchema;
+    parentField: string;
+    control: Control<any>;
+    formValues: any;
+    errors: FieldErrors;
+    handleFieldChange: (props: {
+        key: string | number | symbol;
+        value: any;
+    }) => void;
+    isArray?: boolean;
+    isOptional?: boolean;
+    isNullable?: boolean;
+}
+export declare function resolveSchema({ schema, parentField, control, formValues, errors, handleFieldChange, isOptional, isNullable, depth, }: ResolveSchemaProps & {
+    depth?: number;
+}): import("react/jsx-runtime").JSX.Element | (import("react/jsx-runtime").JSX.Element | null)[] | null;
+export {};

package/dist/components/dynamic-form/schema.d.ts

@@ -0,0 +1,70 @@
+import { Control } from 'react-hook-form';
+import { ZodSchema, z } from 'zod';
+import * as React from 'react';
+type ActionVariables = Record<string, any>;
+export declare enum FormConfigType {
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    DATE = "DATE",
+    ENUM = "ENUM",
+    ARRAY = "ARRAY",
+    BOOLEAN = "BOOLEAN",
+    RECORD = "RECORD",
+    OBJECT = "OBJECT",
+    UNION = "UNION",
+    CREATABLE = "CREATABLE",
+    SELECT = "SELECT",
+    MULTI_SELECT = "MULTI_SELECT"
+}
+type FormConfig = {
+    type: FormConfigType;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    isOptional?: boolean;
+    hasEffects?: boolean;
+    innerSchema?: ZodSchema;
+};
+export declare function getFormConfigTypesFromSchemaDef({ schema, isOptional, }: {
+    schema: ZodSchema<any>;
+    isOptional?: boolean;
+}): FormConfig;
+export type FieldProps = {
+    name: string;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    control: Control<any>;
+    innerSchema?: ZodSchema;
+    variables?: Record<string, ActionVariables | undefined>;
+    isNullable?: boolean;
+    handleFieldChange: ({ key, value, variables, }: {
+        key: keyof z.infer<any>;
+        value: any;
+        variables?: ActionVariables;
+    }) => void;
+};
+export declare function schemaToFormFieldRenderer<T extends ZodSchema>({ schema, errors, renderFieldMap, schemaField, renderLabel, control, variables, onFieldChange, schemaOptions, values, isOptional, isNullable, }: {
+    schema: ZodSchema<any>;
+    errors: any;
+    renderFieldMap?: Record<FormConfigType, (props: FieldProps) => React.ReactNode>;
+    schemaField: string;
+    control: any;
+    onFieldChange: (props: {
+        key: keyof z.infer<T>;
+        value: any;
+        variables?: ActionVariables;
+    }) => void;
+    variables?: Record<string, ActionVariables | undefined>;
+    schemaOptions?: Record<string, any>;
+    renderLabel?: ({ isOptional, schemaField }: {
+        isOptional: boolean;
+        schemaField: string;
+    }) => React.ReactNode;
+    values: Record<keyof z.infer<T>, unknown>;
+    isOptional?: boolean;
+    isNullable?: boolean;
+}): any;
+export {};

package/dist/components/dynamic-form/utils.d.ts

@@ -0,0 +1,12 @@
+import { FieldErrors } from 'react-hook-form';
+import { z } from 'zod';
+
+export declare const transformToNestObject: (error: z.ZodError) => FieldErrors;
+/**
+ * Resolve serialized zod output - This function takes the string output ot the `jsonSchemaToZod` function
+ * and instantiates the zod object correctly.
+ *
+ * @param obj - serialized zod object
+ * @returns resolved zod object
+ */
+export declare function resolveSerializedZodOutput(obj: any): any;

package/dist/components/ui/calendar.d.ts

@@ -0,0 +1,8 @@
+import { DayPicker } from 'react-day-picker';
+import * as React from 'react';
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar };

package/dist/components/ui/code-block.d.ts

@@ -0,0 +1,7 @@
+declare function CodeBlockDemo({ code, language, filename, className, }: {
+    code?: string;
+    language: 'ts' | 'json';
+    filename?: string;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export { CodeBlockDemo };

package/dist/components/ui/collapsible.d.ts

@@ -0,0 +1,5 @@
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+declare const Collapsible: import('../../../node_modules/@types/react').ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & import('../../../node_modules/@types/react').RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: import('../../../node_modules/@types/react').ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & import('../../../node_modules/@types/react').RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: import('../../../node_modules/@types/react').ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & import('../../../node_modules/@types/react').RefAttributes<HTMLDivElement>>;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/components/ui/command.d.ts

@@ -0,0 +1,78 @@
+import * as React from 'react';
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "disabled" | "value" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/components/ui/copy-button.d.ts

@@ -0,0 +1,7 @@
+type CopyButtonProps = {
+    content: string;
+    copyMessage?: string;
+    classname?: string;
+};
+export declare function CopyButton({ content, copyMessage, classname }: CopyButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/date-picker.d.ts

@@ -0,0 +1,23 @@
+import { PropsSingle } from 'react-day-picker';
+import * as React from 'react';
+type CommonProps = Omit<PropsSingle, 'mode' | 'selected' | 'onSelect'> & {
+    value: Date | undefined | null;
+    setValue: (date: Date | undefined | null) => void;
+    clearable?: boolean;
+};
+export type DatePickerProps = (CommonProps & {
+    children?: never;
+    className?: string;
+    placeholder?: string;
+}) | (CommonProps & {
+    children: React.ReactNode;
+    className?: never;
+    placeholder?: string;
+});
+export declare const DatePicker: React.FC<DatePickerProps>;
+export declare const DatePickerOnly: ({ value, setValue, setOpenPopover, clearable, placeholder, className, ...props }: CommonProps & {
+    setOpenPopover?: (open: boolean) => void;
+    placeholder?: string;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/label.d.ts

@@ -0,0 +1,5 @@
+import { VariantProps } from 'class-variance-authority';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as React from 'react';
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: import('class-variance-authority/types').ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/dist/components/ui/popover.d.ts

@@ -0,0 +1,6 @@
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as React from 'react';
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Popover, PopoverTrigger, PopoverContent };

package/dist/components/ui/select.d.ts

@@ -0,0 +1,9 @@
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as React from 'react';
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectItem };

package/dist/components/ui/switch.d.ts

@@ -0,0 +1,4 @@
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import * as React from 'react';
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/dist/components/ui/textarea.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/domains/workflows/context/workflow-run-context.d.ts

@@ -0,0 +1,12 @@
+type WorkflowRunContextType = {
+    result: any;
+    setResult: React.Dispatch<React.SetStateAction<any>>;
+    payload: any;
+    setPayload: React.Dispatch<React.SetStateAction<any>>;
+    clearData: () => void;
+};
+export declare const WorkflowRunContext: import('../../../../node_modules/@types/react').Context<WorkflowRunContextType>;
+export declare function WorkflowRunProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/domains/workflows/index.d.ts

@@ -1,3 +1,5 @@
 export * from './workflow/workflow-traces';
 export * from './workflow/workflow-graph';
 export * from './workflows-table';
+export * from './workflow/workflow-trigger';
+export * from './context/workflow-run-context';

package/dist/domains/workflows/workflow/utils.d.ts

@@ -2,6 +2,7 @@ import { StepCondition } from '@mastra/core/workflows';
 import { Node, Edge } from '@xyflow/react';
 
 export type Condition = {
+    type: 'if' | 'else' | 'when';
     ref: {
         step: {
             id: string;
@@ -10,9 +11,16 @@ export type Condition = {
     };
     query: Record<string, any>;
     conj?: 'and' | 'or';
+    fnString?: never;
+} | {
+    type: 'if' | 'else' | 'when';
+    fnString: string;
+    ref?: never;
+    query?: never;
+    conj?: never;
 };
 export declare const pathAlphabet: string[];
-export declare function extractConditions(group?: StepCondition<any, any>): Condition[];
+export declare function extractConditions(group: StepCondition<any, any>, type: 'if' | 'else' | 'when'): Condition[];
 export declare const contructNodesAndEdges: ({ stepGraph, stepSubscriberGraph, }: {
     stepGraph: any;
     stepSubscriberGraph: any;

package/dist/domains/workflows/workflow/workflow-trigger.d.ts

@@ -0,0 +1,5 @@
+export declare function WorkflowTrigger({ workflowId, baseUrl, setRunId, }: {
+    workflowId: string;
+    baseUrl: string;
+    setRunId?: (runId: string) => void;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/hooks/use-copy-to-clipboard.d.ts

@@ -0,0 +1,9 @@
+type UseCopyToClipboardProps = {
+    text: string;
+    copyMessage?: string;
+};
+export declare function useCopyToClipboard({ text, copyMessage }: UseCopyToClipboardProps): {
+    isCopied: boolean;
+    handleCopy: () => void;
+};
+export {};

package/dist/hooks/use-workflows.d.ts

@@ -1,6 +1,37 @@
 import { Workflow } from '@mastra/core/workflows';
+import { WorkflowRunResult } from '@mastra/client-js';
 
 export declare const useWorkflow: (workflowId: string, baseUrl: string) => {
-    workflow: Workflow<any, any> | null;
+    workflow: Workflow<import('@mastra/core').Step<string, any, any, import('@mastra/core').StepExecutionContext<any, import('@mastra/core').WorkflowContext<any, import('@mastra/core').Step<string, any, any, any>[]>>>[], any> | null;
     isLoading: boolean;
 };
+export declare const useExecuteWorkflow: (baseUrl: string) => {
+    executeWorkflow: ({ workflowId, input }: {
+        workflowId: string;
+        input: any;
+    }) => Promise<WorkflowRunResult>;
+    createWorkflowRun: ({ workflowId, input }: {
+        workflowId: string;
+        input: any;
+    }) => Promise<{
+        runId: string;
+    }>;
+    isExecutingWorkflow: boolean;
+};
+export declare const useWatchWorkflow: (baseUrl: string) => {
+    watchWorkflow: ({ workflowId, runId }: {
+        workflowId: string;
+        runId: string;
+    }) => Promise<void>;
+    isWatchingWorkflow: boolean;
+    watchResult: WorkflowRunResult | null;
+};
+export declare const useResumeWorkflow: (baseUrl: string) => {
+    resumeWorkflow: ({ workflowId, stepId, runId, context, }: {
+        workflowId: string;
+        stepId: string;
+        runId: string;
+        context: any;
+    }) => Promise<Record<string, any>>;
+    isResumingWorkflow: boolean;
+};