@livechat/platform-workflows 0.1.7 → 0.44.0-beta.v1

package/dist/index.d.mts

@@ -1,14 +1,231 @@
-import { Config } from '@livechat/developer-studio-ui-react';
+import * as _emotion_react_jsx_runtime from '@emotion/react/jsx-runtime';
+import * as _emotion_react from '@emotion/react';
+import { SerializedStyles } from '@emotion/react';
+import * as react from 'react';
+import { PropsWithChildren, ComponentProps, ReactElement, ReactNode } from 'react';
+import { CardProps, ModalProps, IconSource } from '@livechat/design-system-react-components';
+import { ActionModalContent, Config } from '@livechat/developer-studio-ui-react';
+import * as _emotion_styled from '@emotion/styled';
+import { IntegrationNames, CredentialType, Credential, WorkflowTaskType, WorkflowHttpTask, WorkflowForkJoinTask, WorkflowJoinTask, WorkflowSwitchTask, WorkflowCustomTaskName, WorkflowConditionTask, WorkflowSwitchCaseTask, WorkflowDoWhileTask, WorkflowLoopTask, WorkflowForEachTask, WorkflowTerminateTask, WorkflowWaitTask, WorkflowInlineBaseTask, WorkflowScriptTask, WorkflowConvertTask, WorkflowConstructTask, WorkflowSimpleTask, WorkflowActionTask, WorkflowAwaitTask, WorkflowNotifyAiAgentTask, WorkflowReasoningTask, WorkflowItemKind, WorkflowTriggerType, WorkflowWebhookTrigger, WorkflowWebhookManualTrigger, WorkflowManualTrigger, WorkflowAgentTrigger, WorkflowRecurringTrigger, WorkflowOneTimeTrigger, ExternalResourceConfig, CredentialDto, AccountDto, ProductDto, WorkflowBundle, WorkflowAggregate, WorkflowDto, ApiPaginatedListQueryParams, ApiPaginatedResult, WorkflowExecutionListItem, WorkflowExecution, WorkflowIntrospection } from '@livechat/developer-studio-api';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import React$1 from 'react';
+import { JSONSchema7 } from 'json-schema';
+import { UiSchema } from '@rjsf/utils';
+
+interface IconStyleProps {
+    height: number;
+    width: number;
+    disabled?: boolean;
+    lowPadding?: boolean;
+    type?: 'circle' | 'rounded';
+}
+declare const baseIcon: (width: number, height: number, primaryColor?: string, disabled?: boolean, lowPadding?: boolean, noFill?: boolean, type?: "circle" | "rounded") => SerializedStyles;
+declare const internalIconStyles: ({ width, height, lowPadding }: {
+    width?: number;
+    height?: number;
+    lowPadding?: boolean;
+}) => SerializedStyles;
+declare const defaultIconStyle: ({ height, width, disabled, lowPadding, type, primaryColor, noFill }: {
+    height: number;
+    width: number;
+    primaryColor?: string;
+    disabled?: boolean;
+    lowPadding?: boolean;
+    noFill?: boolean;
+    type?: "circle" | "rounded";
+}, custom?: SerializedStyles) => SerializedStyles;
+
+declare function GenericIcon({ name, height, width, disabled, lowPadding, type }: IconStyleProps & {
+    name: string;
+}): _emotion_react_jsx_runtime.JSX.Element | null;
+
+declare function UrlIcon({ src, ...styleProps }: IconStyleProps & {
+    src: string;
+}): _emotion_react_jsx_runtime.JSX.Element;
+
+declare function ClickableElement({ onClick, children }: PropsWithChildren<{
+    onClick: () => void;
+}>): _emotion_react_jsx_runtime.JSX.Element;
+
+declare function FloatingElement({ compact, ...rest }: CardProps & {
+    compact?: boolean;
+}): _emotion_react_jsx_runtime.JSX.Element;
+
+declare function RightFramePanel({ children }: PropsWithChildren): _emotion_react_jsx_runtime.JSX.Element;
+declare function LeftFramePanel({ children }: PropsWithChildren): _emotion_react_jsx_runtime.JSX.Element;
+declare function Frame({ topLeft, topRight, bottomLeft, bottomRight, children }: {
+    topLeft?: React.ReactNode;
+    topRight?: React.ReactNode;
+    bottomLeft?: React.ReactNode;
+    bottomRight?: React.ReactNode;
+    children?: React.ReactNode;
+}): _emotion_react_jsx_runtime.JSX.Element;
+
+/** @jsxImportSource @emotion/react */
+interface LoaderProps {
+    overlay?: boolean;
+}
+declare function Loader({ overlay }: LoaderProps): _emotion_react_jsx_runtime.JSX.Element;
+
+type ActionModalProps = {
+    onClose: () => void;
+    isLoading?: boolean;
+    width?: string;
+    height?: string;
+    testId?: string;
+} & ComponentProps<typeof ActionModalContent>;
+declare function ActionModal(props: PropsWithChildren<ActionModalProps>): _emotion_react_jsx_runtime.JSX.Element;
+
+declare function Modal(props: PropsWithChildren<ModalProps>): _emotion_react_jsx_runtime.JSX.Element;
+
+interface BasePaginationProps {
+    currentPage: number;
+    onPageChange: (page: number) => void;
+    className?: string;
+    totalRecords: number;
+    recordsPerPage: number;
+}
+type PaginationProps = BasePaginationProps & ({
+    isSimplified: true;
+    showRangeLabel: true;
+} | {
+    isSimplified?: false;
+    showRangeLabel?: boolean;
+});
+declare function Pagination({ currentPage, onPageChange, isSimplified, totalRecords, recordsPerPage, showRangeLabel }: PaginationProps): _emotion_react_jsx_runtime.JSX.Element;
+
+declare const Sidebar: _emotion_styled.StyledComponent<{
+    theme?: _emotion_react.Theme;
+    as?: React.ElementType;
+} & {
+    width?: string;
+}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+declare const SidebarBodyWrapper: _emotion_styled.StyledComponent<{
+    theme?: _emotion_react.Theme;
+    as?: React.ElementType;
+}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+declare const SidebarBody: _emotion_styled.StyledComponent<{
+    theme?: _emotion_react.Theme;
+    as?: React.ElementType;
+}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+declare function SidebarHeader({ title, description, icon, onClose, children }: {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    icon?: React.ReactNode;
+    onClose?: () => void;
+    children?: React.ReactNode;
+}): _emotion_react_jsx_runtime.JSX.Element;
+declare function SidebarContent({ children }: PropsWithChildren): _emotion_react_jsx_runtime.JSX.Element;
+
+interface ProductIconProps {
+    product: IntegrationNames | string;
+    height: number;
+    width: number;
+    disabled?: boolean;
+    lowPadding?: boolean;
+    type?: 'circle' | 'rounded';
+}
+declare function ProductIcon({ product, height, width, disabled, lowPadding, type }: ProductIconProps): _emotion_react_jsx_runtime.JSX.Element;
+
+type ProductIconCountProps = Omit<ProductIconProps, 'product'> & {
+    count: number;
+};
+declare function ProductIconCount({ count, height, width, disabled, lowPadding, type }: ProductIconCountProps): _emotion_react_jsx_runtime.JSX.Element;
+
+declare function ProductIconWithName({ product }: {
+    product: IntegrationNames;
+}): _emotion_react_jsx_runtime.JSX.Element;
+
+declare function ProductTag({ product, onClick, children }: PropsWithChildren<{
+    product: IntegrationNames;
+    onClick?: () => void;
+}>): _emotion_react_jsx_runtime.JSX.Element;
+
+declare function ProductTagWithName({ product, onClick }: {
+    product: IntegrationNames;
+    onClick?: () => void;
+}): react_jsx_runtime.JSX.Element;
+
+type TreeNodeReference = {
+    type: 'number';
+    value: 0;
+} | {
+    type: 'string';
+    value: 'property';
+};
+interface TreeNode {
+    name: string;
+    value: string;
+    type: string;
+    isSelectable?: boolean;
+    displayValue?: string;
+    isAddable?: boolean;
+    hasAddable?: boolean;
+    reference?: TreeNodeReference;
+    isMatch?: boolean;
+    hasMatch?: boolean;
+    children: TreeNode[];
+}
+interface TreeNodeState {
+    isExpanded: boolean;
+    isSelectable: boolean;
+    isRoot?: boolean;
+}
+type TreeNodeRendererProps = {
+    node: TreeNode;
+    state: TreeNodeState;
+    tag: React.ReactElement;
+};
+type TreeTooltipRendererProps = {
+    node: TreeNode;
+};
+type TreeOptions = {
+    showValues?: boolean;
+    editableReferences?: boolean;
+    addPropertyDefaultName?: string;
+    nodeRenderer?: React.ComponentType<TreeNodeRendererProps>;
+    tooltipRenderer?: (props: TreeTooltipRendererProps) => React.ReactNode;
+};
+
+declare function TreePicker({ data, editableReferences, onSelect, nodeRenderer, tooltipRenderer, showValues, emptyMessage, addPropertyDefaultName, testId }: {
+    data: TreeNode[];
+    onSelect?: (node: TreeNode, isNew?: boolean) => void;
+    emptyMessage?: string;
+    testId?: string;
+} & TreeOptions): _emotion_react_jsx_runtime.JSX.Element;
+
+declare function TreeView({ data, onSelect, editableReferences, search, nodeRenderer, tooltipRenderer, showValues, emptyMessage, addPropertyDefaultName }: {
+    data: TreeNode | TreeNode[] | null;
+    onSelect?: (node: TreeNode, isNew?: boolean) => void;
+    search?: string;
+    emptyMessage?: string;
+} & TreeOptions): _emotion_react_jsx_runtime.JSX.Element;
+
+interface ObjectMeta {
+    properties: Record<string, JSONSchema7 | null>;
+}
+
+declare const replaceReferenceInChildNode: <T>(node: TreeNode, newValue: T | undefined, reference: TreeNodeReference) => TreeNode;
+declare function applySearchMatchingToList(nodes: TreeNode[], search: string | undefined): TreeNode[];
+declare function findNodeByPath(node: TreeNode, path: string): TreeNode | null;
+declare function createGroupNode(data: Partial<TreeNode>, children: TreeNode[]): TreeNode;
+declare function convertSchemaToTree(schema: JSONSchema7, nodeName: string, path: string, meta: {
+    basePath: string;
+    search?: string;
+    reference?: TreeNodeReference;
+}): TreeNode;
+declare function convertObjectToTree(obj: (object & {
+    __meta?: ObjectMeta;
+}) | null, nodeName: string, path: string, meta?: {
+    selectable?: boolean;
+    basePath?: string;
+    search?: string;
+    schema?: JSONSchema7;
+    reference?: TreeNodeReference;
+}): TreeNode;
 
 type WorkflowsConfig = Config & {
     subPath?: string;
     isHeadless: boolean;
-    workflowsAppId: string;
-    workflowsWebhooksAppId: string;
-    workflowsFunctionsUrl: string;
-    workflowAiAgentId: string;
     isLiveChatMode: boolean;
     isTextMode: boolean;
     pusherKey: string;
@@ -23,11 +240,42 @@ declare const getWorkflowsEnv: <T extends keyof WorkflowsConfig>(key: T) => Work
 declare const WORKFLOWS_TEST_SELECTORS: {
     views: {
         workflows: {
+            components: {
+                layout: {
+                    sidebar: {
+                        closeButton: string;
+                    };
+                    pagination: {
+                        paginationArrowButton: {
+                            nextButton: string;
+                            previousButton: string;
+                        };
+                    };
+                };
+                picker: {
+                    itemList: string;
+                };
+            };
             creator: {
                 navbar: {
+                    runsButton: string;
+                    readOnlyTag: string;
                     activateSwitch: string;
                     publishButton: string;
                     editButton: string;
+                    nameInput: string;
+                    editNameButton: string;
+                    draftTag: string;
+                    withDraftTag: string;
+                    backButton: string;
+                    actionMenu: {
+                        button: string;
+                        detailsButton: string;
+                        executionsButton: string;
+                        discardDraftButton: string;
+                        editDraftButton: string;
+                        runButton: string;
+                    };
                 };
                 builder: {
                     nodes: {
@@ -38,29 +286,88 @@ declare const WORKFLOWS_TEST_SELECTORS: {
                             trigger: {
                                 button: string;
                             };
+                            tooltipErrorTrigger: string;
                         };
                     };
                     forms: {
+                        customFieldActions: {
+                            addToTrigerButton: string;
+                            connectTriggerButton: string;
+                            switchTriggerButton: string;
+                        };
                         integrations: {
                             text: {
                                 info: string;
                                 button: string;
                             };
                         };
+                        widgets: {
+                            credentialPicker: {
+                                displayName: string;
+                                removeButton: string;
+                                secondaryInfo: string;
+                                reconnectButton: string;
+                            };
+                            tagsInput: {
+                                formatIcon: string;
+                                triggerIcon: string;
+                                wrapper: string;
+                            };
+                        };
+                        testRun: {
+                            runButton: string;
+                            errorMessageText: string;
+                            status: {
+                                statusText: string;
+                                statusIconSuccess: string;
+                                statusIconError: string;
+                                responseInfo: string;
+                            };
+                        };
+                        testRunModal: {
+                            wrapper: string;
+                            runButton: string;
+                        };
+                    };
+                    controls: {
+                        homeButton: string;
+                    };
+                    handles: {
+                        buttons: {
+                            runButton: string;
+                            removeEdgeButton: string;
+                        };
+                    };
+                };
+                forms: {
+                    allSetAlert: string;
+                    buttons: {
+                        removeButton: string;
                     };
                 };
                 modals: {
-                    addTask: {
+                    add: {
                         wrapper: string;
-                        taskCard: (key: string) => string;
-                        taskCategoryButton: (key: string) => string;
+                        search: string;
+                        card: (key: string) => string;
+                        categoryButton: (key: string) => string;
                         saveButton: string;
+                        noMatchingText: (kind: string) => string;
                     };
-                    addTrigger: {
+                    delete: {
                         wrapper: string;
-                        saveButton: string;
-                        triggerCard: (key: string) => string;
-                        triggerCategoryButton: (key: string) => string;
+                        deleteButton: string;
+                        cancelButton: string;
+                    };
+                    execute: {
+                        wrapper: string;
+                        cancelButton: string;
+                        runButton: string;
+                    };
+                    import: {
+                        wrapper: string;
+                        cancelButton: string;
+                        confirmButton: string;
                     };
                     publish: {
                         wrapper: string;
@@ -72,6 +379,14 @@ declare const WORKFLOWS_TEST_SELECTORS: {
                     element: {
                         wrapper: string;
                     };
+                    executions: {
+                        noPublishedWorkflow: string;
+                        noWorkflowRunsYet: string;
+                        noMatchingExecution: string;
+                        card: (id: string) => string;
+                        executionDate: string;
+                        status: string;
+                    };
                     details: {
                         executions: {
                             list: {
@@ -79,9 +394,6 @@ declare const WORKFLOWS_TEST_SELECTORS: {
                                 status: string;
                             };
                         };
-                        panel: {
-                            historyTab: string;
-                        };
                         info: {
                             dateCreated: string;
                             dateUpdated: string;
@@ -93,13 +405,24 @@ declare const WORKFLOWS_TEST_SELECTORS: {
             };
             list: {
                 grid: {
+                    filters: {
+                        wrapper: string;
+                        statusFilter: string;
+                        clearFiltersButton: string;
+                    };
                     table: {
                         wrapper: string;
                         body: string;
                         menuTrigger: string;
                         activateSwitch: string;
                         infoButton: string;
+                        emptyInfo: string;
                         workflowItem: (id: string) => string;
+                        withDraftTag: string;
+                        draftTag: string;
+                        clearFiltersButton: string;
+                        productIconsRow: string;
+                        productIconCount: string;
                     };
                 };
                 view: {
@@ -113,30 +436,503 @@ declare const WORKFLOWS_TEST_SELECTORS: {
                     previewTemplate: {
                         wrapper: string;
                         useButton: string;
+                        productsUsed: string;
+                    };
+                    previewImport: {
+                        wrapper: string;
+                        useButton: string;
+                        closeButton: string;
+                    };
+                    previewFallback: {
+                        wrapper: string;
+                        closeButton: string;
                     };
                 };
                 home: {
+                    noTemplatesFoundInfo: string;
                     cards: {
                         template: {
                             wrapper: string;
                         };
+                        scratch: {
+                            cardHeader: string;
+                        };
                     };
                 };
             };
+            common: {
+                errorPage: {
+                    backButton: string;
+                    homeButton: string;
+                    refreshButton: string;
+                };
+                tree: {
+                    listElementExpanderButton: string;
+                };
+            };
         };
     };
 };
 
+/** @jsxImportSource @emotion/react */
+
+declare function ErrorBoundary(): ReactElement;
+
+/** @jsxImportSource @emotion/react */
+
 interface LoginErrorPageProps {
     errorImage: React.ReactNode;
     welcomeImage: React.ReactNode;
     onAuthorize: () => void;
 }
-declare function LoginErrorPage({ errorImage, welcomeImage, onAuthorize }: LoginErrorPageProps): JSX.Element;
+declare function LoginErrorPage({ errorImage, welcomeImage, onAuthorize }: LoginErrorPageProps): ReactElement;
+
+/** @jsxImportSource @emotion/react */
+
+declare function NotFoundPage(): ReactElement;
 
-interface WorkflowsModuleProps {
-    waitlistImage: React$1.ReactNode;
+declare function WorkflowBuilder({ fitView, viewport }: {
+    fitView?: boolean;
+    viewport?: {
+        padding: {
+            left?: number;
+            right?: number;
+            top?: number;
+            bottom?: number;
+        };
+    };
+}): _emotion_react_jsx_runtime.JSX.Element;
+
+declare function WorkflowCreatorFrame({ children }: PropsWithChildren): react_jsx_runtime.JSX.Element;
+
+declare function WorkflowCreatorSkeleton(): react_jsx_runtime.JSX.Element;
+
+declare function WorkflowPreviewFrame({ children }: PropsWithChildren): react_jsx_runtime.JSX.Element;
+
+declare function WorkflowPreviewSkeleton(): react_jsx_runtime.JSX.Element;
+
+declare enum CredentialKind {
+    Internal = "internal",
+    Custom = "custom"
+}
+interface CredentialConfig {
+    name: string;
+    provider: string;
+    product?: string;
+    kind: CredentialKind;
+    type: CredentialType;
+    specification: {
+        schema: JSONSchema7;
+        uiSchema: UiSchema;
+    };
+    customization: {
+        description: string;
+    };
+    template: Credential;
+    metadata: {
+        isComplete?: boolean;
+        isHidden?: boolean;
+    };
+}
+
+declare enum WorkflowDomain {
+    Chats = "chats",
+    Tickets = "tickets",
+    Customers = "customers",
+    Agents = "agents",
+    General = "general"
+}
+interface WorkflowDomainConfig {
+    name: string;
+    displayName: string;
+}
+
+interface WorkflowTaskDefinitionMap {
+    [WorkflowTaskType.http]: WorkflowHttpTask;
+    [WorkflowTaskType.forkJoin]: WorkflowForkJoinTask;
+    [WorkflowTaskType.join]: WorkflowJoinTask;
+    [WorkflowTaskType.switch]: WorkflowSwitchTask;
+    [WorkflowCustomTaskName.condition]: WorkflowConditionTask;
+    [WorkflowCustomTaskName.switchCase]: WorkflowSwitchCaseTask;
+    [WorkflowTaskType.doWhile]: WorkflowDoWhileTask;
+    [WorkflowCustomTaskName.loop]: WorkflowLoopTask;
+    [WorkflowCustomTaskName.forEach]: WorkflowForEachTask;
+    [WorkflowTaskType.terminate]: WorkflowTerminateTask;
+    [WorkflowTaskType.wait]: WorkflowWaitTask;
+    [WorkflowTaskType.inline]: WorkflowInlineBaseTask;
+    [WorkflowCustomTaskName.script]: WorkflowScriptTask;
+    [WorkflowCustomTaskName.convert]: WorkflowConvertTask;
+    [WorkflowCustomTaskName.construct]: WorkflowConstructTask;
+    [WorkflowTaskType.simple]: WorkflowSimpleTask;
+    [WorkflowCustomTaskName.action]: WorkflowActionTask;
+    [WorkflowCustomTaskName.awaitAgent]: WorkflowAwaitTask;
+    [WorkflowCustomTaskName.notifyAgent]: WorkflowNotifyAiAgentTask;
+    [WorkflowCustomTaskName.reasoning]: WorkflowReasoningTask;
+}
+interface WorkflowsTriggerDefinitionMap {
+    [WorkflowTriggerType.webhook]: WorkflowWebhookTrigger;
+    [WorkflowTriggerType.webhookManual]: WorkflowWebhookManualTrigger;
+    [WorkflowTriggerType.manual]: WorkflowManualTrigger;
+    [WorkflowTriggerType.agent]: WorkflowAgentTrigger;
+    [WorkflowTriggerType.recurring]: WorkflowRecurringTrigger;
+    [WorkflowTriggerType.oneTime]: WorkflowOneTimeTrigger;
+}
+type WorkflowItemFlags = {
+    isHidden: boolean;
+    isRemovable: boolean;
+    isSelectable: boolean;
+    isEditable: boolean;
+};
+type WorkflowItemBaseMetadata = {
+    outputBasePath: string | null;
+    inputBasePath: string;
+    credentialPath?: string;
+    isHidden: boolean;
+};
+type WorkflowItemMetadata = WorkflowItemBaseMetadata;
+declare enum WorkflowItemTag {
+    AI = "ai"
+}
+/**
+ * Describes the nature of a task/trigger so consumers (UI, AI agent prompts)
+ * can group, filter, and pick icons without inspecting `displayName`.
+ *
+ * For tasks the value reflects the side-effect the task performs.
+ * For triggers it reflects the verb of the event that fires the trigger
+ * (or `invoke`/`control` for non-event-driven orchestration triggers).
+ *
+ * Convention:
+ * - `read`    — find/get/list/search + pure AI compute returning data
+ * - `create`  — adds a new entity; trigger: "X was created"
+ * - `upsert`  — create-or-update
+ * - `update`  — modifies an existing entity; trigger: "X changed"
+ * - `delete`  — remove/archive/close/end + "X was removed"
+ * - `send`    — outbound communication (message, notification, transcript)
+ * - `invoke`  — side-effectful action that does not fit CRUD
+ *               (run job, generic HTTP, arbitrary script, notify agent,
+ *                manually-triggered workflow)
+ * - `control` — workflow control-flow primitive (fork/join/cond/switch/loop/
+ *               wait/terminate) and system trigger orchestration
+ */
+declare enum WorkflowOperation {
+    Read = "read",
+    Create = "create",
+    Upsert = "upsert",
+    Update = "update",
+    Delete = "delete",
+    Send = "send",
+    Invoke = "invoke",
+    Control = "control"
+}
+/**
+ * Entity the task/trigger acts on. Always namespaced with the provider id
+ * (`<provider>:<entity>`, kebab-case) so the same entity name across two
+ * providers can't collide.
+ *
+ * Allowed values come from per-provider `<PROVIDER>_SUBJECTS` constants
+ * (e.g. `BIGCOMMERCE_SUBJECTS`, `LIVECHAT_SUBJECTS`) which `satisfies
+ * Record<string, \`${IntegrationNames.X}:${string}\`>` so typos and missing
+ * namespaces fail to compile. Control-flow primitives and generic HTTP /
+ * script tasks leave it `undefined`.
+ */
+type WorkflowSubject = `${string}:${string}`;
+interface WorkflowItemCustomization {
+    domain: WorkflowDomain | null;
+    provider: string;
+    operation: WorkflowOperation;
+    subject?: WorkflowSubject;
+    product?: string;
+    displayName: string;
+    description: string;
+    shortDescription: string;
+    tags?: WorkflowItemTag[];
+    icon?: string;
+    flags: WorkflowItemFlags;
+}
+interface WorkflowItemSpecificationRef<TType> {
+    type: 'single' | 'array' | 'array-element';
+    value: TType;
+    subject?: WorkflowDomain;
+}
+interface WorkflowItemInputBinding {
+    outputPath: string;
+    inputPath: string;
+    inputFormat?: string;
+}
+interface WorkflowItemSpecification {
+    input?: JSONSchema7;
+    inputUi?: UiSchema;
+    output?: JSONSchema7;
+    outputUi?: UiSchema;
+    inputReferences?: Record<string, WorkflowItemSpecificationRef<string>[]>;
+    inputResources?: Record<string, WorkflowItemSpecificationRef<string>[]>;
+    outputReferences?: Record<string, WorkflowItemSpecificationRef<string>[]>;
+    outputResources?: Record<string, WorkflowItemSpecificationRef<string>[]>;
+    outputBindings?: WorkflowItemInputBinding[];
+}
+interface WorkflowItemSpecifications<TData> {
+    default: string;
+    latest: string;
+    versions: Record<string, WorkflowItemSpecification & {
+        metadata: WorkflowItemMetadata;
+        template: TData;
+    }>;
+}
+interface WorkflowItemConfigBase<TData> {
+    key: string;
+    kind: WorkflowItemKind;
+    customization: WorkflowItemCustomization;
+    specifications: WorkflowItemSpecifications<TData>;
+}
+/** Union of all task definition types */
+type AnyTaskDefinition = WorkflowTaskDefinitionMap[keyof WorkflowTaskDefinitionMap];
+/** Union of all trigger definition types */
+type AnyTriggerDefinition = WorkflowsTriggerDefinitionMap[keyof WorkflowsTriggerDefinitionMap];
+/**
+ * Generic task config - use with specific TDefinition for type safety
+ * @example const myConfig: WorkflowTaskConfig<WorkflowHttpTask> = { ... }
+ */
+type WorkflowTaskConfig<TDefinition extends AnyTaskDefinition = AnyTaskDefinition> = {
+    kind: typeof WorkflowItemKind.Task;
+} & WorkflowItemConfigBase<TDefinition>;
+/**
+ * Generic trigger config - use with specific TDefinition for type safety
+ */
+type WorkflowTriggerConfig<TDefinition extends AnyTriggerDefinition = AnyTriggerDefinition> = {
+    kind: typeof WorkflowItemKind.Trigger;
+} & WorkflowItemConfigBase<TDefinition>;
+type WorkflowItemConfig = WorkflowTaskConfig | WorkflowTriggerConfig;
+
+interface ProviderProductConfig {
+    name: string;
+    displayName: string;
+    icon?: string;
+}
+interface ProviderConfig {
+    name: string;
+    displayName: string;
+    icon?: string;
+    isHidden?: boolean;
+    products?: Record<string, ProviderProductConfig>;
+}
+
+declare enum WorkflowRefClass {
+    Reference = "reference",
+    Resource = "resource"
+}
+declare enum WorkflowReferenceKind {
+    Resource = "resource",
+    Entity = "entity",
+    Property = "property"
+}
+declare enum WorkflowReferenceMatchingStrategy {
+    ExactOnly = "exact_only",
+    Semantic = "semantic"
+}
+type WorkflowReferenceDefinition = JSONSchema7 & {
+    class: WorkflowRefClass.Reference;
+    provider: string;
+    name: string;
+    displayName: string;
+    pluralDisplayName: string;
+    domain: WorkflowDomain | null;
+    product?: string;
+    visible: true;
+    configs?: {
+        dependencies?: Record<string, JSONSchema7>;
+        matching?: {
+            strategy: WorkflowReferenceMatchingStrategy;
+        };
+        external?: ExternalResourceConfig;
+    };
+} & ({
+    kind: WorkflowReferenceKind.Resource;
+    resource: {
+        name: string;
+        path: string;
+    };
+} | {
+    kind: WorkflowReferenceKind.Property | WorkflowReferenceKind.Entity;
+});
+type WorkflowResourceDefinition = JSONSchema7 & {
+    class: WorkflowRefClass.Resource;
+    provider: string;
+    name: string;
+    displayName: string;
+    pluralDisplayName: string;
+};
+
+interface Configuration {
+    providers: Record<string, ProviderConfig>;
+    domains: Record<WorkflowDomain, WorkflowDomainConfig>;
+    credentials: Record<string, CredentialConfig>;
+    items: Record<string, WorkflowItemConfig>;
+    resources: Record<string, WorkflowResourceDefinition>;
+    references: Record<string, WorkflowReferenceDefinition>;
+}
+type ProviderConfiguration = ProviderConfig & {
+    defaultCredential?: CredentialConfig;
+    credentials: Record<string, CredentialConfig>;
+    items: Record<string, WorkflowItemConfig>;
+    resources: Record<string, WorkflowResourceDefinition>;
+};
+interface Specification {
+    providers: Record<string, ProviderConfiguration>;
+    raw: Configuration;
+}
+
+type WorkflowCredential = CredentialDto & {
+    isInternal: boolean;
+};
+
+interface WorkflowContextOptions {
+    readonly?: boolean;
+    validation?: {
+        hidden?: boolean;
+        strategy?: 'non-blocking';
+    };
+    selection?: {
+        hidden?: boolean;
+    };
+    status?: {
+        hidden?: boolean;
+    };
 }
-declare function WorkflowsModule({ waitlistImage }: WorkflowsModuleProps): react_jsx_runtime.JSX.Element;
+interface WorkflowContextDependencies {
+    specification: Specification;
+    account?: AccountDto;
+    credentials?: WorkflowCredential[];
+    products?: ProductDto[];
+}
+interface WorkflowContextStoreActions {
+    invalidate: (entry: WorkflowContextStoreEntry, options?: {
+        immediate?: boolean;
+    }) => void;
+}
+type WorkflowContextStoreEntry = {
+    scope: 'resources';
+    key: keyof WorkflowBundle;
+} | {
+    scope: 'dependencies';
+    key: keyof WorkflowContextDependencies;
+};
+
+interface WorkflowCreatorInput {
+    aggregate: WorkflowAggregate;
+}
+interface WorkflowCreatorStoreData {
+    input: WorkflowCreatorInput;
+    dependencies: WorkflowContextDependencies;
+    options?: WorkflowContextOptions;
+}
+type WorkflowCreatorStoreActions = WorkflowContextStoreActions & {
+    flush: () => void;
+};
+interface WorkflowCreatorStoreApi {
+    getWorkflow(id: string, version?: number): Promise<WorkflowDto>;
+    getWorkflowExecutions(id: string, queryParams?: ApiPaginatedListQueryParams): Promise<ApiPaginatedResult<WorkflowExecutionListItem>>;
+    getWorkflowExecution(workflowId: string, executionId: string): Promise<WorkflowExecution>;
+    getWorkflowIntrospection(id: string, version?: number): Promise<WorkflowIntrospection>;
+}
+interface WorkflowCreatorStore {
+    data: WorkflowCreatorStoreData;
+    actions: WorkflowCreatorStoreActions;
+    api: WorkflowCreatorStoreApi;
+}
+
+declare function WorkflowCreatorProvider({ store: creatorStore, children }: PropsWithChildren<{
+    store: WorkflowCreatorStore;
+}>): _emotion_react_jsx_runtime.JSX.Element;
+
+interface WorkflowPreviewInput {
+    workflow: WorkflowDto;
+}
+interface WorkflowPreviewStoreData {
+    input: WorkflowPreviewInput;
+    dependencies: WorkflowContextDependencies;
+    options?: WorkflowContextOptions;
+}
+interface WorkflowPreviewStore {
+    data: WorkflowPreviewStoreData;
+}
+
+declare function WorkflowPreviewProvider({ store: previewStore, children }: PropsWithChildren<{
+    store: WorkflowPreviewStore;
+}>): _emotion_react_jsx_runtime.JSX.Element;
+
+type NewWorkflowInitialData = {
+    type: 'template';
+    templateId: string;
+} | {
+    type: 'workflow';
+    workflow: Partial<WorkflowDto>;
+};
+type WorkflowCreatorTarget = {
+    mode: 'idle';
+} | {
+    mode: 'new';
+    initialData?: NewWorkflowInitialData;
+} | {
+    mode: 'existing';
+    workflowId: string;
+};
+
+declare function useWorkflowCreatorTargetFromUrl(): WorkflowCreatorTarget | undefined;
+
+declare function WorkflowCreator({ readonly }?: {
+    readonly?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function Workflow({ options, target }?: {
+    options?: WorkflowContextOptions;
+    target?: WorkflowCreatorTarget;
+}): react_jsx_runtime.JSX.Element | undefined;
+
+interface CreatedOnFilterValue {
+    from: string | null;
+    to: string | null;
+}
+
+interface WorkflowFilterDefinition<K extends string = string> {
+    key: K;
+    label: string;
+    icon: IconSource;
+    displayValue: string | null;
+    isSelected: boolean;
+    loadedFromUrl?: boolean;
+    onClear: () => void;
+    renderContent: () => ReactNode;
+}
+interface WorkflowsFiltersProps<K extends string = string> {
+    clearFilters: () => void;
+    filterDefinitions: WorkflowFilterDefinition<K>[];
+}
+declare function WorkflowFilters<K extends string = string>({ filterDefinitions, clearFilters }: WorkflowsFiltersProps<K>): _emotion_react_jsx_runtime.JSX.Element;
+declare const WorkflowBaseFilterKey: {
+    readonly Status: "status";
+    readonly Draft: "draft";
+    readonly CreatedBy: "createdBy";
+    readonly CreatedOn: "createdOn";
+};
+type WorkflowBaseFilterKey = (typeof WorkflowBaseFilterKey)[keyof typeof WorkflowBaseFilterKey];
+type WorkflowBaseStatusValue = 'active' | 'inactive' | null;
+type WorkflowBaseDraftValue = 'draft' | 'published' | null;
+type WorkflowBaseCreatedByValue = string[];
+type WorkflowBaseCreatedOnValue = CreatedOnFilterValue;
+interface BaseFilterConfig<TValue> {
+    isSelected: boolean;
+    loadedFromUrl?: boolean;
+    onChange: (value: TValue) => void;
+    onClear: () => void;
+    value: TValue;
+}
+interface WorkflowBaseFiltersConfig {
+    createdBy: BaseFilterConfig<WorkflowBaseCreatedByValue>;
+    createdOn: BaseFilterConfig<WorkflowBaseCreatedOnValue>;
+    draft: BaseFilterConfig<WorkflowBaseDraftValue>;
+    status: BaseFilterConfig<WorkflowBaseStatusValue>;
+}
+declare function useBaseWorkflowFilters(config: WorkflowBaseFiltersConfig): WorkflowFilterDefinition<WorkflowBaseFilterKey>[];
+
+declare function Workflows(): _emotion_react_jsx_runtime.JSX.Element;
 
-export { LoginErrorPage as LoginError, WORKFLOWS_TEST_SELECTORS, type WorkflowsConfig, WorkflowsModule, config, getWorkflowsEnv, setWorkflowsConfig };
+export { ActionModal, ClickableElement, ErrorBoundary, FloatingElement, Frame, GenericIcon, type IconStyleProps, LeftFramePanel, Loader, LoginErrorPage as LoginError, Modal, type NewWorkflowInitialData, NotFoundPage as NotFound, Pagination, ProductIcon, ProductIconCount, type ProductIconProps, ProductIconWithName, ProductTag, ProductTagWithName, RightFramePanel, Sidebar, SidebarBody, SidebarBodyWrapper, SidebarContent, SidebarHeader, type TreeNode, type TreeNodeReference, type TreeNodeRendererProps, type TreeNodeState, type TreeOptions, TreePicker, type TreeTooltipRendererProps, TreeView, UrlIcon, WORKFLOWS_TEST_SELECTORS, Workflow, type WorkflowBaseCreatedByValue, type WorkflowBaseCreatedOnValue, type WorkflowBaseDraftValue, WorkflowBaseFilterKey, type WorkflowBaseStatusValue, WorkflowBuilder, type WorkflowContextDependencies, type WorkflowContextOptions, type WorkflowContextStoreEntry, WorkflowCreator, WorkflowCreatorFrame, type WorkflowCreatorInput, WorkflowCreatorProvider, WorkflowCreatorSkeleton, type WorkflowCreatorStore, type WorkflowCreatorStoreActions, type WorkflowCreatorStoreApi, type WorkflowCreatorStoreData, type WorkflowCreatorTarget, type WorkflowFilterDefinition, WorkflowFilters, WorkflowPreviewFrame, WorkflowPreviewProvider, WorkflowPreviewSkeleton, Workflows, type WorkflowsConfig, applySearchMatchingToList, baseIcon, config, convertObjectToTree, convertSchemaToTree, createGroupNode, defaultIconStyle, findNodeByPath, getWorkflowsEnv, internalIconStyles, replaceReferenceInChildNode, setWorkflowsConfig, useBaseWorkflowFilters, useWorkflowCreatorTargetFromUrl };