@codingfactory/task-engine-client 0.1.0 → 1.0.0

package/dist/components/index.d.ts

@@ -14,8 +14,12 @@ export { default as RecurringTemplateForm } from './recurrence/RecurringTemplate
 export { default as RecurringTemplateList } from './recurrence/RecurringTemplateList.vue';
 export { default as TaskListView } from './list/TaskListView.vue';
 export { default as TaskSavedFilterTabs } from './list/TaskSavedFilterTabs.vue';
+export { default as WorkflowForm } from './workflows/WorkflowForm.vue';
+export { default as WorkflowList } from './workflows/WorkflowList.vue';
+export { default as WorkflowLogs } from './workflows/WorkflowLogs.vue';
 export { default as TaskPriorityIcon } from './shared/TaskPriorityIcon.vue';
 export { default as TaskEntityWidget } from './shared/TaskEntityWidget.vue';
+export { default as TaskImportExportPanel } from './shared/TaskImportExportPanel.vue';
 export { default as TaskNotificationToast } from './shared/TaskNotificationToast.vue';
 export { default as TaskQuickCreate } from './shared/TaskQuickCreate.vue';
 export { default as EscalationActions } from './task/EscalationActions.vue';
@@ -25,5 +29,7 @@ export { default as TaskChecklist } from './task/TaskChecklist.vue';
 export { default as TaskComments } from './task/TaskComments.vue';
 export { default as TaskDetailView } from './task/TaskDetail.vue';
 export { default as TaskForm } from './task/TaskForm.vue';
+export { default as TaskTimeTracker } from './task/TaskTimeTracker.vue';
 export { default as TaskStatusBadge } from './task/TaskStatusBadge.vue';
 export { default as TaskTimeline } from './task/TaskTimeline.vue';
+export { TaskDetailPage, TaskListPage, TaskDashboardPage, TaskRecurringPage } from './pages';

package/dist/components/pages/TaskDashboardPage.vue.d.ts

@@ -0,0 +1,11 @@
+type __VLS_Props = {
+    userId: string | number;
+    echo?: unknown;
+    autoConnect?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "navigate-to-task": (taskId: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onNavigate-to-task"?: (taskId: string) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/pages/TaskDetailPage.vue.d.ts

@@ -0,0 +1,13 @@
+type __VLS_Props = {
+    taskId: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "navigate-back": () => any;
+    "task-deleted": (taskId: string) => any;
+    "edit-task": (taskId: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onNavigate-back"?: () => any;
+    "onTask-deleted"?: (taskId: string) => any;
+    "onEdit-task"?: (taskId: string) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/pages/TaskListPage.vue.d.ts

@@ -0,0 +1,12 @@
+type __VLS_Props = {
+    entityContext?: {
+        type: string;
+        id: string;
+    } | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "navigate-to-task": (taskId: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onNavigate-to-task"?: (taskId: string) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/pages/TaskRecurringPage.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "navigate-to-task": (taskId: string) => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    "onNavigate-to-task"?: (taskId: string) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/pages/index.d.ts

@@ -0,0 +1,4 @@
+export { default as TaskDetailPage } from './TaskDetailPage.vue';
+export { default as TaskListPage } from './TaskListPage.vue';
+export { default as TaskDashboardPage } from './TaskDashboardPage.vue';
+export { default as TaskRecurringPage } from './TaskRecurringPage.vue';

package/dist/components/shared/TaskImportExportPanel.vue.d.ts

@@ -0,0 +1,15 @@
+import type { TaskImportResult } from '@/types';
+type __VLS_Props = {
+    busy?: boolean;
+    importing?: boolean;
+    exporting?: boolean;
+    result?: TaskImportResult | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    import: (file: File) => any;
+    export: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onImport?: (file: File) => any;
+    onExport?: () => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/task/TaskDetail.vue.d.ts

@@ -1,6 +1,7 @@
-import type { TaskDetail } from '@/types';
+import type { TaskDetail, TaskTimeEntry } from '@/types';
 type __VLS_Props = {
     task: TaskDetail | null;
+    activeTimer?: TaskTimeEntry | null;
     busy?: boolean;
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
@@ -8,6 +9,8 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     cancel: (taskId: string) => any;
     delete: (taskId: string) => any;
     edit: (taskId: string) => any;
+    "start-timer": (taskId: string) => any;
+    "stop-timer": (taskId: string) => any;
     reopen: (taskId: string) => any;
     "acknowledge-escalation": (taskId: string) => any;
     "snooze-escalation": (payload: {
@@ -23,11 +26,22 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     "toggle-checklist-item": (itemId: string) => any;
     "remove-checklist-item": (itemId: string) => any;
     "reorder-checklist-items": (itemIds: string[]) => any;
+    "add-manual-time-entry": (payload: {
+        taskId: string;
+        duration_minutes: number;
+        description?: string | null;
+    }) => any;
+    "delete-time-entry": (payload: {
+        taskId: string;
+        entryId: string;
+    }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onComplete?: (taskId: string) => any;
     onCancel?: (taskId: string) => any;
     onDelete?: (taskId: string) => any;
     onEdit?: (taskId: string) => any;
+    "onStart-timer"?: (taskId: string) => any;
+    "onStop-timer"?: (taskId: string) => any;
     onReopen?: (taskId: string) => any;
     "onAcknowledge-escalation"?: (taskId: string) => any;
     "onSnooze-escalation"?: (payload: {
@@ -43,5 +57,14 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     "onToggle-checklist-item"?: (itemId: string) => any;
     "onRemove-checklist-item"?: (itemId: string) => any;
     "onReorder-checklist-items"?: (itemIds: string[]) => any;
+    "onAdd-manual-time-entry"?: (payload: {
+        taskId: string;
+        duration_minutes: number;
+        description?: string | null;
+    }) => any;
+    "onDelete-time-entry"?: (payload: {
+        taskId: string;
+        entryId: string;
+    }) => any;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/components/task/TaskTimeTracker.vue.d.ts

@@ -0,0 +1,28 @@
+import type { TaskDetail, TaskManualTimeEntryPayload, TaskTimeEntry } from '@/types';
+type __VLS_Props = {
+    task: TaskDetail;
+    activeTimer?: TaskTimeEntry | null;
+    busy?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "start-timer": (taskId: string) => any;
+    "stop-timer": (taskId: string) => any;
+    "add-manual-entry": (payload: TaskManualTimeEntryPayload & {
+        taskId: string;
+    }) => any;
+    "delete-entry": (payload: {
+        taskId: string;
+        entryId: string;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onStart-timer"?: (taskId: string) => any;
+    "onStop-timer"?: (taskId: string) => any;
+    "onAdd-manual-entry"?: (payload: TaskManualTimeEntryPayload & {
+        taskId: string;
+    }) => any;
+    "onDelete-entry"?: (payload: {
+        taskId: string;
+        entryId: string;
+    }) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/workflows/WorkflowForm.vue.d.ts

@@ -0,0 +1,14 @@
+import type { TaskWorkflow, TaskWorkflowMutationPayload, TaskWorkflowUpdatePayload } from '@/types';
+type __VLS_Props = {
+    workflow?: TaskWorkflow | null;
+    mode?: 'create' | 'edit';
+    submitting?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: () => any;
+    submit: (payload: TaskWorkflowMutationPayload | TaskWorkflowUpdatePayload) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: () => any;
+    onSubmit?: (payload: TaskWorkflowMutationPayload | TaskWorkflowUpdatePayload) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/workflows/WorkflowList.vue.d.ts

@@ -0,0 +1,34 @@
+import type { TaskWorkflow } from '@/types';
+type __VLS_Props = {
+    workflows: TaskWorkflow[];
+    loading?: boolean;
+    error?: string | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    move: (payload: {
+        workflow: TaskWorkflow;
+        direction: "up" | "down";
+    }) => any;
+    edit: (workflow: TaskWorkflow) => any;
+    remove: (workflow: TaskWorkflow) => any;
+    duplicate: (workflow: TaskWorkflow) => any;
+    toggle: (payload: {
+        workflow: TaskWorkflow;
+        isEnabled: boolean;
+    }) => any;
+    logs: (workflow: TaskWorkflow) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onMove?: (payload: {
+        workflow: TaskWorkflow;
+        direction: "up" | "down";
+    }) => any;
+    onEdit?: (workflow: TaskWorkflow) => any;
+    onRemove?: (workflow: TaskWorkflow) => any;
+    onDuplicate?: (workflow: TaskWorkflow) => any;
+    onToggle?: (payload: {
+        workflow: TaskWorkflow;
+        isEnabled: boolean;
+    }) => any;
+    onLogs?: (workflow: TaskWorkflow) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/workflows/WorkflowLogs.vue.d.ts

@@ -0,0 +1,19 @@
+import type { TaskWorkflowLog, WorkflowLogStatus } from '@/types';
+type __VLS_Props = {
+    logs: TaskWorkflowLog[];
+    loading?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    refresh: (filters: {
+        status?: WorkflowLogStatus;
+        date_from?: string;
+        date_to?: string;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRefresh?: (filters: {
+        status?: WorkflowLogStatus;
+        date_from?: string;
+        date_to?: string;
+    }) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/composables/index.d.ts

@@ -5,3 +5,5 @@ export { useTaskNotificationFeed } from './useTaskNotificationFeed';
 export { useTaskPresence } from './useTaskPresence';
 export { useTaskSavedFilters } from './useTaskSavedFilters';
 export { useTaskWebSocket } from './useTaskWebSocket';
+export { useTaskWorkflows } from './useTaskWorkflows';
+export { useRecurringTemplates } from './useRecurringTemplates';

package/dist/composables/useRecurringTemplates.d.ts

@@ -0,0 +1,114 @@
+import type { RecurringTemplate, RecurringTemplateFilters, RecurringTemplateMutationPayload, RecurringTemplateUpdatePayload, TaskDetail } from '@/types';
+export declare function useRecurringTemplates(): {
+    templates: import("vue").ComputedRef<{
+        id: string;
+        tenant_id: string;
+        task_template_id: string | null;
+        task_template: {
+            id: string;
+            name: string;
+        } | null;
+        title: string | null;
+        description: string | null;
+        rrule: string;
+        rrule_human: string;
+        timezone: string;
+        taskable_type: string | null;
+        taskable_id: string | null;
+        primary_assignee_id: string | null;
+        priority: import("@/types").TaskPriority;
+        priority_label?: string | null;
+        due_offset_hours: number | null;
+        tags: string[];
+        is_active: boolean;
+        skip_holidays: boolean;
+        business_hours_only: boolean;
+        chain_mode: boolean;
+        last_generated_at: string | null;
+        next_occurrence_at: string | null;
+        metadata: Record<string, unknown> | null;
+        created_by: string | number | null;
+        created_at: string | null;
+        updated_at: string | null;
+        deleted_at: string | null;
+        history: {
+            id: string;
+            recurring_template_id: string;
+            task_id: string;
+            occurrence_date: string;
+            generated_at: string;
+            created_at: string | null;
+            task: {
+                id: string;
+                display_number_formatted: string;
+                title: string;
+                status: import("@/types").TaskStatus;
+                priority: import("@/types").TaskPriority;
+            } | null;
+        }[];
+    }[]>;
+    currentTemplate: import("vue").ComputedRef<{
+        id: string;
+        tenant_id: string;
+        task_template_id: string | null;
+        task_template: {
+            id: string;
+            name: string;
+        } | null;
+        title: string | null;
+        description: string | null;
+        rrule: string;
+        rrule_human: string;
+        timezone: string;
+        taskable_type: string | null;
+        taskable_id: string | null;
+        primary_assignee_id: string | null;
+        priority: import("@/types").TaskPriority;
+        priority_label?: string | null;
+        due_offset_hours: number | null;
+        tags: string[];
+        is_active: boolean;
+        skip_holidays: boolean;
+        business_hours_only: boolean;
+        chain_mode: boolean;
+        last_generated_at: string | null;
+        next_occurrence_at: string | null;
+        metadata: Record<string, unknown> | null;
+        created_by: string | number | null;
+        created_at: string | null;
+        updated_at: string | null;
+        deleted_at: string | null;
+        history: {
+            id: string;
+            recurring_template_id: string;
+            task_id: string;
+            occurrence_date: string;
+            generated_at: string;
+            created_at: string | null;
+            task: {
+                id: string;
+                display_number_formatted: string;
+                title: string;
+                status: import("@/types").TaskStatus;
+                priority: import("@/types").TaskPriority;
+            } | null;
+        }[];
+    } | null>;
+    loading: import("vue").ComputedRef<boolean>;
+    saving: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+    pagination: import("vue").ComputedRef<{
+        current_page: number;
+        last_page: number;
+        per_page: number;
+        total: number;
+    }>;
+    loadTemplates: (filters?: RecurringTemplateFilters) => Promise<void>;
+    loadTemplate: (id: string) => Promise<RecurringTemplate | null>;
+    createTemplate: (payload: RecurringTemplateMutationPayload) => Promise<RecurringTemplate | null>;
+    updateTemplate: (id: string, payload: RecurringTemplateUpdatePayload) => Promise<RecurringTemplate | null>;
+    deleteTemplate: (id: string) => Promise<boolean>;
+    pauseTemplate: (id: string) => Promise<RecurringTemplate | null>;
+    resumeTemplate: (id: string) => Promise<RecurringTemplate | null>;
+    generateFromTemplate: (id: string) => Promise<TaskDetail | null>;
+};

package/dist/composables/useTaskDetail.d.ts

@@ -1,5 +1,5 @@
 import { type MaybeRefOrGetter } from 'vue';
-import type { TaskCommentPayload, TaskDetail, TaskEscalationSnoozePayload } from '@/types';
+import type { TaskCommentPayload, TaskDetail, TaskEscalationSnoozePayload, TaskManualTimeEntryPayload } from '@/types';
 export declare function useTaskDetail(taskId?: MaybeRefOrGetter<string | null | undefined>): {
     task: import("vue").ComputedRef<{
         comments: {
@@ -30,6 +30,24 @@ export declare function useTaskDetail(taskId?: MaybeRefOrGetter<string | null |
             position: number;
             template_item_id?: string | null;
         }[];
+        time_entries: {
+            id: string;
+            task_id: string;
+            user_id: string;
+            user: {
+                id: string | number;
+                name: string;
+                avatar_url?: string;
+            } | null;
+            started_at: string | null;
+            stopped_at: string | null;
+            duration_minutes: number | null;
+            description: string | null;
+            is_manual: boolean;
+            is_running: boolean;
+            created_at: string | null;
+            updated_at: string | null;
+        }[];
         watchers: {
             id: string | number;
             name: string;
@@ -172,6 +190,7 @@ export declare function useTaskDetail(taskId?: MaybeRefOrGetter<string | null |
             subtasks_complete?: boolean;
             custom_field_required?: string[];
         } | null;
+        time_tracked_minutes?: number | null;
         tags: {
             id: string;
             name: string;
@@ -190,6 +209,24 @@ export declare function useTaskDetail(taskId?: MaybeRefOrGetter<string | null |
         created_at: string;
         updated_at: string;
     } | null>;
+    activeTimer: import("vue").ComputedRef<{
+        id: string;
+        task_id: string;
+        user_id: string;
+        user: {
+            id: string | number;
+            name: string;
+            avatar_url?: string;
+        } | null;
+        started_at: string | null;
+        stopped_at: string | null;
+        duration_minutes: number | null;
+        description: string | null;
+        is_manual: boolean;
+        is_running: boolean;
+        created_at: string | null;
+        updated_at: string | null;
+    } | null>;
     loading: import("vue").ComputedRef<boolean>;
     error: import("vue").ComputedRef<string | null>;
     loadTask: (id?: string | null) => Promise<TaskDetail | null>;
@@ -199,6 +236,10 @@ export declare function useTaskDetail(taskId?: MaybeRefOrGetter<string | null |
     addChecklistItem: (title: string) => Promise<TaskDetail | null>;
     toggleChecklistItem: (itemId: string) => Promise<TaskDetail | null>;
     removeChecklistItem: (itemId: string) => Promise<TaskDetail | null>;
+    startTimer: (taskIdOverride?: string | null) => Promise<TaskDetail | null>;
+    stopTimer: (taskIdOverride?: string | null) => Promise<TaskDetail | null>;
+    addManualTimeEntry: (payload: TaskManualTimeEntryPayload, taskIdOverride?: string | null) => Promise<TaskDetail | null>;
+    deleteTimeEntry: (entryId: string, taskIdOverride?: string | null) => Promise<TaskDetail | null>;
     completeTask: (id: string, note?: string) => Promise<TaskDetail>;
     reopenTask: (id: string) => Promise<TaskDetail>;
     cancelTask: (id: string) => Promise<TaskDetail>;

package/dist/composables/useTaskWorkflows.d.ts

@@ -0,0 +1,133 @@
+import type { TaskWorkflowFilters } from '@/types';
+interface UseTaskWorkflowsOptions {
+    autoLoad?: boolean;
+    initialFilters?: TaskWorkflowFilters;
+}
+export declare function useTaskWorkflows(options?: UseTaskWorkflowsOptions): {
+    filters: import("vue").ComputedRef<{
+        search?: string;
+        trigger_type?: import("@/types").WorkflowTriggerType;
+        page?: number;
+        per_page?: number;
+    }>;
+    workflows: import("vue").ComputedRef<{
+        id: string;
+        tenant_id: string;
+        name: string;
+        description: string | null;
+        trigger_type: import("@/types").WorkflowTriggerType;
+        trigger_type_label?: string | null;
+        trigger_config: Record<string, unknown> | null;
+        conditions: {
+            field: import("@/types").WorkflowConditionField;
+            operator: import("@/types").WorkflowConditionOperator;
+            value?: unknown;
+        }[];
+        actions: {
+            type: import("@/types").WorkflowActionType;
+            value?: unknown;
+            config?: Record<string, unknown>;
+        }[];
+        is_enabled: boolean;
+        position: number;
+        stop_processing: boolean;
+        metadata: Record<string, unknown> | null;
+        created_by: string | null;
+        execution_count: number;
+        last_executed_at: string | null;
+        created_at: string | null;
+        updated_at: string | null;
+    }[]>;
+    pagination: import("vue").ComputedRef<{
+        current_page: number;
+        last_page: number;
+        per_page: number;
+        total: number;
+    }>;
+    currentWorkflow: import("vue").ComputedRef<{
+        id: string;
+        tenant_id: string;
+        name: string;
+        description: string | null;
+        trigger_type: import("@/types").WorkflowTriggerType;
+        trigger_type_label?: string | null;
+        trigger_config: Record<string, unknown> | null;
+        conditions: {
+            field: import("@/types").WorkflowConditionField;
+            operator: import("@/types").WorkflowConditionOperator;
+            value?: unknown;
+        }[];
+        actions: {
+            type: import("@/types").WorkflowActionType;
+            value?: unknown;
+            config?: Record<string, unknown>;
+        }[];
+        is_enabled: boolean;
+        position: number;
+        stop_processing: boolean;
+        metadata: Record<string, unknown> | null;
+        created_by: string | null;
+        execution_count: number;
+        last_executed_at: string | null;
+        created_at: string | null;
+        updated_at: string | null;
+    } | null>;
+    testResult: import("vue").ComputedRef<{
+        workflow: {
+            id: string;
+            tenant_id: string;
+            name: string;
+            description: string | null;
+            trigger_type: import("@/types").WorkflowTriggerType;
+            trigger_type_label?: string | null;
+            trigger_config: Record<string, unknown> | null;
+            conditions: {
+                field: import("@/types").WorkflowConditionField;
+                operator: import("@/types").WorkflowConditionOperator;
+                value?: unknown;
+            }[];
+            actions: {
+                type: import("@/types").WorkflowActionType;
+                value?: unknown;
+                config?: Record<string, unknown>;
+            }[];
+            is_enabled: boolean;
+            position: number;
+            stop_processing: boolean;
+            metadata: Record<string, unknown> | null;
+            created_by: string | null;
+            execution_count: number;
+            last_executed_at: string | null;
+            created_at: string | null;
+            updated_at: string | null;
+        };
+        task_id: string;
+        trigger_matched: boolean;
+        conditions_met: boolean;
+        actions: {
+            type: string;
+            success: boolean;
+            message: string;
+            data: Record<string, unknown>;
+            dry_run: boolean;
+        }[];
+    } | null>;
+    logsByWorkflow: import("vue").ComputedRef<{
+        [x: string]: import("@/types").PaginatedResponse<import("@/types").TaskWorkflowLog> | undefined;
+    }>;
+    loading: import("vue").ComputedRef<boolean>;
+    saving: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+    reload: () => Promise<void>;
+    setFilters: (value: TaskWorkflowFilters) => Promise<void>;
+    fetchWorkflow: (id: string) => Promise<import("@/types").TaskWorkflow>;
+    createWorkflow: (data: import("@/types").TaskWorkflowMutationPayload) => Promise<import("@/types").TaskWorkflow>;
+    updateWorkflow: (id: string, data: import("@/types").TaskWorkflowUpdatePayload) => Promise<import("@/types").TaskWorkflow>;
+    deleteWorkflow: (id: string) => Promise<void>;
+    toggleWorkflow: (id: string, isEnabled?: boolean) => Promise<import("@/types").TaskWorkflow>;
+    duplicateWorkflow: (workflow: import("@/types").TaskWorkflow) => Promise<import("@/types").TaskWorkflow>;
+    moveWorkflow: (id: string, direction: "up" | "down") => Promise<void>;
+    fetchLogs: (workflowId: string, filters?: import("@/types").TaskWorkflowLogFilters) => Promise<import("@/types").PaginatedResponse<import("@/types").TaskWorkflowLog>>;
+    runTest: (workflowId: string, taskId: string, context?: Record<string, unknown>) => Promise<import("@/types").TaskWorkflowTestResult>;
+};
+export {};