@cargo-ai/api 1.0.1

package/build/src/store/orchestration.d.ts

@@ -0,0 +1,942 @@
+import { type OrchestrationTypes } from "cargo-domain-types";
+import type { EitherOr } from "cargo-utils";
+import { z } from "zod/v4";
+import type { StateCreator } from "zustand";
+import type { BackendToFrontend, DateToString } from "../types.js";
+import type { Ai } from "./ai.js";
+import type { Segmentation } from "./segmentation.js";
+import type { Storage } from "./storage.js";
+type GlobalRecord<K extends keyof any, T> = Record<K, T>;
+export declare namespace Orchestration {
+    type Play = BackendToFrontend<OrchestrationTypes.Play>;
+    type PlayRunCreationRule = BackendToFrontend<OrchestrationTypes.PlayRunCreationRule>;
+    type PlayHealthAlertAction = BackendToFrontend<OrchestrationTypes.PlayHealthAlertAction>;
+    type PlaySchedule = BackendToFrontend<OrchestrationTypes.PlaySchedule>;
+    type PlayScheduleCron = BackendToFrontend<OrchestrationTypes.PlayScheduleCron>;
+    type PlayScheduleDbt = BackendToFrontend<OrchestrationTypes.PlayScheduleDbt>;
+    type PlayScheduleRealtime = BackendToFrontend<OrchestrationTypes.PlayScheduleRealtime>;
+    type PlayScheduleDependency = BackendToFrontend<OrchestrationTypes.PlayScheduleDependency>;
+    type PlayScheduleWatch = BackendToFrontend<OrchestrationTypes.PlayScheduleWatch>;
+    type PlayTemplate = BackendToFrontend<OrchestrationTypes.PlayTemplate>;
+    type Tool = BackendToFrontend<OrchestrationTypes.Tool>;
+    type ToolTemplate = BackendToFrontend<OrchestrationTypes.ToolTemplate>;
+    type ToolIcon = BackendToFrontend<OrchestrationTypes.ToolIcon>;
+    type Workflow = BackendToFrontend<OrchestrationTypes.Workflow>;
+    type WorkflowTemplate = BackendToFrontend<OrchestrationTypes.WorkflowTemplate>;
+    type WorkflowNode = BackendToFrontend<OrchestrationTypes.WorkflowNode>;
+    type Node = BackendToFrontend<OrchestrationTypes.Node>;
+    type RunMetric = BackendToFrontend<OrchestrationTypes.RunMetric>;
+    type RecordMetric = BackendToFrontend<OrchestrationTypes.RecordMetric>;
+    type ReleaseStatus = BackendToFrontend<OrchestrationTypes.ReleaseStatus>;
+    type Release = BackendToFrontend<OrchestrationTypes.Release>;
+    type ReleaseTestRecord = BackendToFrontend<OrchestrationTypes.ReleaseTestRecord>;
+    type ReleaseFormField = BackendToFrontend<OrchestrationTypes.ReleaseFormField>;
+    type BatchStatus = BackendToFrontend<OrchestrationTypes.BatchStatus>;
+    type Batch = BackendToFrontend<OrchestrationTypes.Batch>;
+    type BatchData = BackendToFrontend<OrchestrationTypes.BatchData>;
+    type BatchDataRunsReset = BackendToFrontend<OrchestrationTypes.BatchDataRunsReset>;
+    type BatchDataRunsFilter = BackendToFrontend<OrchestrationTypes.BatchDataRunsFilter>;
+    type RunStatus = BackendToFrontend<OrchestrationTypes.RunStatus>;
+    type RecordStatus = BackendToFrontend<OrchestrationTypes.RecordStatus>;
+    type Execution = BackendToFrontend<OrchestrationTypes.Execution>;
+    type ExecutionStatus = BackendToFrontend<OrchestrationTypes.ExecutionStatus>;
+    type Run = BackendToFrontend<OrchestrationTypes.Run>;
+    type Record = BackendToFrontend<OrchestrationTypes.Record>;
+    type ExecutionsFilter = BackendToFrontend<OrchestrationTypes.ExecutionsFilter>;
+    type ExecutionsFilterCondition = BackendToFrontend<OrchestrationTypes.ExecutionsFilterCondition>;
+    type ExecutionsFilterGroup = BackendToFrontend<OrchestrationTypes.ExecutionsFilterGroup>;
+    type Template = BackendToFrontend<OrchestrationTypes.Template>;
+    type TemplateCategory = BackendToFrontend<OrchestrationTypes.TemplateCategory>;
+    type TemplateNode = BackendToFrontend<OrchestrationTypes.TemplateNode>;
+    const reshapeReleaseFormFieldsToSchemas: (formFields: OrchestrationTypes.ReleaseFormField[]) => {
+        jsonSchema: import("jsonschema").Schema;
+        uiSchema: globalThis.Record<string, unknown>;
+    };
+    const zodNode: z.ZodIntersection<z.ZodObject<{
+        uuid: z.ZodString;
+        slug: z.ZodString;
+        config: z.ZodRecord<z.ZodString, z.ZodAny>;
+        description: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maximumAttempts: z.ZodOptional<z.ZodNumber>;
+            initialInterval: z.ZodOptional<z.ZodNumber>;
+            backoffCoefficient: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        childrenUuids: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        fallbackChildUuid: z.ZodOptional<z.ZodString>;
+        fallbackOnFailure: z.ZodBoolean;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            native: "native";
+        }>;
+        actionSlug: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            connector: "connector";
+        }>;
+        actionSlug: z.ZodString;
+        integrationSlug: z.ZodString;
+        connectorUuid: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            tool: "tool";
+        }>;
+        toolUuid: z.ZodString;
+        releaseUuid: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            agent: "agent";
+        }>;
+        agentUuid: z.ZodString;
+        releaseUuid: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    namespace Api {
+        export type ListWorkflowsResult = {
+            workflows: Workflow[];
+        };
+        export type CreatePlayPayload = DateToString<{
+            name: string;
+            description?: string;
+            modelUuid: string;
+            filter?: Segmentation.Filter;
+            sort?: Segmentation.Sort;
+            limit?: number;
+            trackingColumnSlugs?: string[];
+            changeKinds: Segmentation.ChangeKind[];
+            runCreationRule: PlayRunCreationRule;
+            schedule?: Omit<PlayScheduleCron, "temporalScheduleWorkflowId"> | PlayScheduleDbt | PlayScheduleRealtime | PlayScheduleDependency | Omit<PlayScheduleWatch, "temporalScheduleWorkflowId" | "meta">;
+            folderUuid?: string;
+        }>;
+        export type CreatePlayResult = {
+            play: Play;
+        };
+        export const zodCreatePlayErrorReason: z.ZodEnum<{
+            folderNotFound: "folderNotFound";
+            modelNotFound: "modelNotFound";
+            datasetNotFound: "datasetNotFound";
+            connectorNotFound: "connectorNotFound";
+            integrationNotFound: "integrationNotFound";
+            datasetNotCompatible: "datasetNotCompatible";
+            integrationNotCompatible: "integrationNotCompatible";
+            failedToSchedule: "failedToSchedule";
+            invalidFilter: "invalidFilter";
+            failedToCreateSegment: "failedToCreateSegment";
+        }>;
+        export type ListPlaysResult = {
+            plays: Play[];
+        };
+        export type UpdatePlayPayload = DateToString<{
+            uuid: string;
+            description?: string | null;
+            isEnabled?: boolean;
+            name?: string;
+            filter?: Segmentation.Filter;
+            sort?: Segmentation.Sort | null;
+            limit?: number | null;
+            trackingColumnSlugs?: string[] | null;
+            changeKinds?: Segmentation.ChangeKind[];
+            runCreationRule?: PlayRunCreationRule;
+            healthThreshold?: number;
+            healthAlertActions?: PlayHealthAlertAction[];
+            schedule?: Omit<PlayScheduleCron, "temporalScheduleWorkflowId"> | PlayScheduleDbt | PlayScheduleRealtime | PlayScheduleDependency | Omit<PlayScheduleWatch, "temporalScheduleWorkflowId" | "meta"> | null;
+            folderUuid?: string | null;
+        }>;
+        export type UpdatePlayResult = {
+            play: Play;
+        };
+        export const zodUpdatePlayErrorReason: z.ZodEnum<{
+            folderNotFound: "folderNotFound";
+            modelNotFound: "modelNotFound";
+            datasetNotFound: "datasetNotFound";
+            connectorNotFound: "connectorNotFound";
+            integrationNotFound: "integrationNotFound";
+            datasetNotCompatible: "datasetNotCompatible";
+            integrationNotCompatible: "integrationNotCompatible";
+            failedToSchedule: "failedToSchedule";
+            invalidFilter: "invalidFilter";
+            segmentNotFound: "segmentNotFound";
+            playNotFound: "playNotFound";
+            playNotDeployed: "playNotDeployed";
+            failedToUpdateSegment: "failedToUpdateSegment";
+        }>;
+        export const zodRemovePlayErrorReason: z.ZodEnum<{
+            playNotFound: "playNotFound";
+            failedToRemoveSegment: "failedToRemoveSegment";
+        }>;
+        export type CreateToolPayload = DateToString<{
+            name: string;
+            icon: ToolIcon;
+            description?: string;
+            folderUuid?: string;
+        }>;
+        export type CreateToolResult = {
+            tool: Tool;
+        };
+        export type ListToolsResult = {
+            tools: Tool[];
+        };
+        export type UpdateToolPayload = DateToString<{
+            uuid: string;
+            name?: string;
+            icon?: ToolIcon;
+            description?: string | null;
+            folderUuid?: string | null;
+        }>;
+        export type UpdateToolResult = {
+            tool: Tool;
+        };
+        export const zodUpdateToolErrorReason: z.ZodEnum<{
+            folderNotFound: "folderNotFound";
+            toolNotFound: "toolNotFound";
+            toolIsReadOnly: "toolIsReadOnly";
+        }>;
+        export const zodRemoveToolErrorReason: z.ZodEnum<{
+            toolNotFound: "toolNotFound";
+            toolIsReadOnly: "toolIsReadOnly";
+        }>;
+        export type ComputeNodePayload = DateToString<{
+            node: NodePayload;
+            groupContext?: GlobalRecord<string, any>;
+            context: GlobalRecord<string, any>;
+        }>;
+        export type ComputeNodeResult = {
+            computedConfig: GlobalRecord<string, any>;
+        };
+        type NodePayload = Omit<Node, "childrenUuids"> & {
+            childrenUuids: Array<string | null>;
+        };
+        export type ExecuteNodePayload = DateToString<{
+            workflowUuid: string;
+            releaseUuid: string;
+            node: NodePayload;
+            computedConfig: GlobalRecord<string, any>;
+            context: GlobalRecord<string, any>;
+            groupContext?: GlobalRecord<string, any>;
+        }>;
+        export type ExecuteNodeGroupItemResult = {
+            item: any;
+            executions: GlobalRecord<string, {
+                outcome: "executing";
+                message: string;
+            } | {
+                outcome: "executed";
+                data: GlobalRecord<string, any> | null;
+                creditsUsedCount: number;
+                childIndex?: number;
+            } | {
+                outcome: "notExecuted";
+                reason: "actionFailed";
+                message: string;
+                creditsUsedCount: number;
+            }>;
+            computedConfigs: GlobalRecord<string, {
+                outcome: "computed";
+                computedConfig: GlobalRecord<string, any>;
+            } | {
+                outcome: "notComputed";
+                errorMessage: string;
+            }>;
+            error: string | undefined;
+        };
+        export type ExecuteNodePendingResult = {
+            status: "pending";
+            message: string;
+        };
+        export type ExecuteNodeSuccessResult = {
+            status: "success";
+            data: GlobalRecord<string, any> | Array<GlobalRecord<string, any>> | null;
+            creditsUsedCount: number;
+            groupItems?: ExecuteNodeGroupItemResult[];
+            childIndex?: number;
+        };
+        export type ExecuteNodeErrorResult = {
+            status: "error";
+            message: string;
+            creditsUsedCount: number;
+            groupItems?: ExecuteNodeGroupItemResult[];
+        };
+        export type ExecuteNodeResult = ExecuteNodePendingResult | ExecuteNodeSuccessResult | ExecuteNodeErrorResult;
+        export const zodExecuteNodeErrorReason: z.ZodEnum<{
+            releaseNotFound: "releaseNotFound";
+        }>;
+        export type CreateBatchPayload = DateToString<{
+            workflowUuid: string;
+            data: {
+                kind: "segment";
+                segmentUuid: string;
+            } | {
+                kind: "change";
+                changeUuid: string;
+                changeKinds: Segmentation.ChangeKind[];
+            } | {
+                kind: "file";
+                s3Filename: string;
+                mappings?: GlobalRecord<string, string>;
+            } | {
+                kind: "filter";
+                modelUuid: string;
+                filter?: Segmentation.Filter;
+                sort?: Segmentation.Sort;
+                limit?: number;
+            } | {
+                kind: "runs";
+                filter: BatchDataRunsFilter;
+                reset: BatchDataRunsReset;
+            } | {
+                kind: "recordIds";
+                modelUuid: string;
+                ids: string[];
+            } | {
+                kind: "group";
+                items: any[];
+                parentBatchUuid?: string;
+                parentRunUuid: string;
+                parentNodeUuid: string;
+            } | {
+                kind: "records";
+                records: GlobalRecord<string, any>[];
+            } | {
+                kind: "schedule";
+                modelUuid: string;
+                segmentUuid: string;
+                changeKinds: Segmentation.ChangeKind[];
+                skip?: boolean;
+            } | {
+                kind: "form";
+                records: GlobalRecord<string, unknown>[];
+                parentBatchUuid?: string;
+                parentRunUuid?: string;
+                parentNodeUuid?: string;
+            };
+        }>;
+        export type CreateBatchResult = {
+            batch: Batch;
+        };
+        export const zodCreateBatchErrorReason: z.ZodEnum<{
+            notEnoughCredits: "notEnoughCredits";
+            workflowNotFound: "workflowNotFound";
+            invalidReleaseOrCustomNodes: "invalidReleaseOrCustomNodes";
+            nodesNotFound: "nodesNotFound";
+            startNodeNotFound: "startNodeNotFound";
+            dataError: "dataError";
+            failedToStart: "failedToStart";
+        }>;
+        export type PreviewBatchPayload = DateToString<{
+            workflowUuid: string;
+            data: {
+                kind: "segment";
+                segmentUuid: string;
+            } | {
+                kind: "change";
+                changeUuid: string;
+                changeKinds: Segmentation.ChangeKind[];
+            } | {
+                kind: "file";
+                s3Filename: any;
+            } | {
+                kind: "filter";
+                modelUuid: string;
+                filter?: Segmentation.Filter;
+                sort?: Segmentation.Sort;
+                limit?: number;
+            } | {
+                kind: "runs";
+                runUuids: string[];
+                reset: BatchDataRunsReset;
+            } | {
+                kind: "recordIds";
+                modelUuid: string;
+                ids: string[];
+            } | {
+                kind: "group";
+                items: any[];
+                parentBatchUuid?: string;
+                parentRunUuid: string;
+                parentNodeUuid: string;
+            } | {
+                kind: "records";
+                records: GlobalRecord<string, any>[];
+            } | {
+                kind: "schedule";
+                modelUuid: string;
+                segmentUuid: string;
+                changeKinds: Segmentation.ChangeKind[];
+            };
+        }>;
+        export type PreviewBatchResult = {
+            records: GlobalRecord<string, any>[];
+            columns: Storage.Column[];
+            count: number;
+        };
+        export const zodPreviewBatchErrorReason: z.ZodEnum<{
+            segmentNotFound: "segmentNotFound";
+            workflowNotFound: "workflowNotFound";
+            modelLinkedToWorkflow: "modelLinkedToWorkflow";
+            noModelLinkedToWorkflow: "noModelLinkedToWorkflow";
+            failedToFetchFromClient: "failedToFetchFromClient";
+        }>;
+        export type ListBatchesPayload = DateToString<{
+            workflowUuids?: string[];
+            releaseUuid?: string;
+            parentBatchUuid?: string;
+            parentRunUuid?: string;
+            parentNodeUuid?: string;
+            statuses?: BatchStatus[];
+            hasRuns?: boolean;
+            isSkipped?: boolean;
+            isFinished?: boolean;
+            includedDataKinds?: Array<BatchData["kind"]>;
+            excludedDataKinds?: Array<BatchData["kind"]>;
+            limit?: number;
+            offset?: number;
+        }>;
+        export type ListBatchesResult = {
+            batches: Batch[];
+        };
+        export type GetBatchResult = {
+            batch: Batch;
+        };
+        export const zodCancelBatchErrorReason: z.ZodEnum<{
+            failedToStart: "failedToStart";
+            batchNotFound: "batchNotFound";
+            batchAlreadyFinished: "batchAlreadyFinished";
+        }>;
+        export type DownloadBatchPayload = DateToString<{
+            uuid: string;
+            outputNodeSlug: string;
+        }>;
+        export type DownloadBatchResult = {
+            url: string;
+        };
+        export const zodDownloadBatchErrorReason: z.ZodEnum<{
+            batchNotFound: "batchNotFound";
+            batchNotFinished: "batchNotFinished";
+            batchNotSupported: "batchNotSupported";
+        }>;
+        export type CreateRunPayload = DateToString<{
+            workflowUuid: string;
+            releaseUuid?: string;
+            data: unknown;
+        }>;
+        export type CreateRunResult = {
+            run: Run;
+        };
+        export const zodCreateRunErrorReason: z.ZodEnum<{
+            notEnoughCredits: "notEnoughCredits";
+            workflowNotFound: "workflowNotFound";
+            invalidReleaseOrCustomNodes: "invalidReleaseOrCustomNodes";
+            nodesNotFound: "nodesNotFound";
+            startNodeNotFound: "startNodeNotFound";
+            failedToStart: "failedToStart";
+            invalidData: "invalidData";
+        }>;
+        export type GetRunResult = {
+            run: Run;
+            runComputedConfigs: GlobalRecord<string, any>;
+            runContext: GlobalRecord<string, any>;
+        };
+        export type ListRunsPayload = DateToString<{
+            workflowUuid: string;
+            batchUuid?: string;
+            releaseUuid?: string;
+            statuses?: RunStatus[];
+            parentBatchUuid?: string;
+            parentUuid?: string;
+            parentNodeUuid?: string;
+            isGroupParent?: boolean;
+            recordId?: string;
+            recordTitle?: string;
+            recordTitleOrId?: string;
+            isFinished?: boolean;
+            executionsFilter?: ExecutionsFilter;
+            createdAfter?: string;
+            createdBefore?: string;
+            limit?: number;
+            offset?: number;
+        }>;
+        export type CountRunsPayload = DateToString<{
+            workflowUuid: string;
+            batchUuid?: string;
+            releaseUuid?: string;
+            statuses?: RunStatus[];
+            parentBatchUuid?: string;
+            parentUuid?: string;
+            parentNodeUuid?: string;
+            isGroupParent?: boolean;
+            recordId?: string;
+            recordTitle?: string;
+            recordTitleOrId?: string;
+            isFinished?: boolean;
+            executionsFilter?: ExecutionsFilter;
+            createdAfter?: string;
+            createdBefore?: string;
+        }>;
+        export type DownloadRunsPayload = DateToString<{
+            workflowUuid: string;
+            batchUuid?: string;
+            releaseUuid?: string;
+            statuses?: RunStatus[];
+            parentBatchUuid?: string;
+            parentUuid?: string;
+            parentNodeUuid?: string;
+            isGroupParent?: boolean;
+            recordId?: string;
+            recordTitle?: string;
+            recordTitleOrId?: string;
+            isFinished?: boolean;
+            executionsFilter?: ExecutionsFilter;
+            createdAfter?: string;
+            createdBefore?: string;
+        }>;
+        export type ReviewRunPayload = DateToString<{
+            uuid: string;
+            computedConfig: GlobalRecord<string, any>;
+        }>;
+        export type ReviewRunResult = {
+            run: Run;
+        };
+        export type CancelRunsPayload = DateToString<{
+            workflowUuid: string;
+        } & EitherOr<{
+            uuids: string[];
+        }, {
+            recordId?: string;
+            recordTitle?: string;
+            recordTitleOrId?: string;
+            releaseUuid?: string;
+            batchUuid?: string;
+            parentBatchUuid?: string;
+            parentUuid?: string;
+            parentNodeUuid?: string;
+            isGroupParent?: boolean;
+            executionsFilter?: ExecutionsFilter;
+        }>>;
+        export const zodCancelRunsErrorReason: z.ZodEnum<{
+            failedToStart: "failedToStart";
+        }>;
+        export type ListRunsResult = {
+            runs: Run[];
+            count: number;
+        };
+        export type CountRunsResult = {
+            count: number;
+        };
+        export type DownloadRunsResult = {
+            url: string;
+        };
+        export type GetRunMetricsPayload = DateToString<{
+            workflowUuid: string;
+            releaseUuid?: string;
+            batchUuid?: string;
+            createdAfter?: string;
+            createdBefore?: string;
+        }>;
+        export type GetRunMetricsResult = {
+            runMetrics: RunMetric[];
+        };
+        export type ListRecordsPayload = DateToString<{
+            workflowUuid: string;
+            ids?: string[];
+            title?: string;
+            titleOrId?: string;
+            releaseUuid?: string;
+            batchUuid?: string;
+            statuses?: RecordStatus[];
+            parentBatchUuid?: string;
+            parentRunUuid?: string;
+            parentNodeUuid?: string;
+            isGroupParent?: boolean;
+            executionsFilter?: ExecutionsFilter;
+            createdAfter?: string;
+            createdBefore?: string;
+            limit?: number;
+            offset?: number;
+        }>;
+        export type ListRecordsResult = {
+            records: Record[];
+            count: number;
+        };
+        export type CountRecordsPayload = DateToString<{
+            workflowUuid: string;
+            ids?: string[];
+            title?: string;
+            titleOrId?: string;
+            releaseUuid?: string;
+            batchUuid?: string;
+            statuses?: RecordStatus[];
+            parentBatchUuid?: string;
+            parentRunUuid?: string;
+            parentNodeUuid?: string;
+            isGroupParent?: boolean;
+            executionsFilter?: ExecutionsFilter;
+            createdAfter?: string;
+            createdBefore?: string;
+        }>;
+        export type CountRecordsResult = {
+            count: number;
+        };
+        export type DownloadRecordsPayload = DateToString<{
+            workflowUuid: string;
+            ids?: string[];
+            title?: string;
+            titleOrId?: string;
+            releaseUuid?: string;
+            batchUuid?: string;
+            statuses?: RunStatus[];
+            parentBatchUuid?: string;
+            parentRunUuid?: string;
+            parentNodeUuid?: string;
+            isGroupParent?: boolean;
+            executionsFilter?: ExecutionsFilter;
+            createdAfter?: string;
+            createdBefore?: string;
+        }>;
+        export type DownloadRecordsResult = {
+            url: string;
+        };
+        export type CancelRecordsPayload = DateToString<{
+            workflowUuid: string;
+        } & EitherOr<{
+            ids: string[];
+        }, {
+            title?: string;
+            titleOrId?: string;
+            releaseUuid?: string;
+            batchUuid?: string;
+            parentBatchUuid?: string;
+            parentRunUuid?: string;
+            parentNodeUuid?: string;
+            isGroupParent?: boolean;
+            executionsFilter?: ExecutionsFilter;
+        }>>;
+        export type GetRecordMetricsPayload = DateToString<{
+            workflowUuid: string;
+            releaseUuid?: string;
+            batchUuid?: string;
+            createdAfter?: string;
+            createdBefore?: string;
+        }>;
+        export type GetRecordMetricsResult = {
+            recordMetrics: RecordMetric[];
+        };
+        export const zodCancelRecordsErrorReason: z.ZodEnum<{
+            failedToStart: "failedToStart";
+            tooManyRecordsSelected: "tooManyRecordsSelected";
+        }>;
+        export type GetReleaseResult = {
+            release: Release;
+        };
+        export type ListReleasesPayload = DateToString<{
+            workflowUuid?: string;
+            userUuid?: string;
+            statuses?: ReleaseStatus[];
+            limit?: number;
+            offset?: number;
+        }>;
+        export type ListReleaseResult = {
+            releases: Release[];
+        };
+        export type GetDraftReleasePayload = DateToString<{
+            workflowUuid: string;
+        }>;
+        export type GetDraftReleaseResult = {
+            release: Release;
+        };
+        export const zodGetDraftReleaseErrorReason: z.ZodEnum<{
+            workflowNotFound: "workflowNotFound";
+        }>;
+        export type DeployDraftReleasePayload = DateToString<{
+            workflowUuid: string;
+            nodes: NodePayload[];
+            formFields: ReleaseFormField[] | null;
+            version: string;
+            description?: string;
+            options?: {
+                connectorUuidsByIntegrationSlug?: GlobalRecord<string, string>;
+                modelUuidsByIntegrationSlug?: GlobalRecord<string, string>;
+            };
+        }>;
+        export type DeployDraftReleaseResult = {
+            release: Release;
+        };
+        export const zodDeployDraftReleaseErrorReason: z.ZodEnum<{
+            draftReleaseNotFound: "draftReleaseNotFound";
+            duplicatedReleaseVersion: "duplicatedReleaseVersion";
+            workflowNotFound: "workflowNotFound";
+            draftReleaseNodesAreInvalid: "draftReleaseNodesAreInvalid";
+            failedToReconciliateNodes: "failedToReconciliateNodes";
+        }>;
+        export type UpdateDraftReleasePayload = DateToString<{
+            workflowUuid: string;
+            parentUuid?: string;
+            nodes?: NodePayload[];
+            testRecords?: ReleaseTestRecord[];
+            formFields?: ReleaseFormField[] | null;
+            options?: {
+                connectorUuidsByIntegrationSlug?: GlobalRecord<string, string>;
+                modelUuidsByIntegrationSlug?: GlobalRecord<string, string>;
+            };
+        }>;
+        export type UpdateDraftReleaseResult = {
+            release: Release;
+        };
+        export const zodUpdateDraftReleaseErrorReason: z.ZodEnum<{
+            draftReleaseNotFound: "draftReleaseNotFound";
+            invalidParent: "invalidParent";
+            workflowNotFound: "workflowNotFound";
+            failedToReconciliateNodes: "failedToReconciliateNodes";
+        }>;
+        export type ListTemplatesResult = {
+            templates: Template[];
+        };
+        export type GetTemplatePayload = DateToString<{
+            slug: string;
+        }>;
+        export type GetTemplateResult = {
+            template: Template;
+        };
+        export const zodGetTemplateErrorReason: z.ZodEnum<{
+            templateNotFound: "templateNotFound";
+        }>;
+        export {};
+    }
+    const batchKeys: {
+        all: (workspaceUuid: string) => readonly ["batches", string];
+        get: (workspaceUuid: string, uuid: string) => readonly ["batches", string, string];
+        list: (workspaceUuid: string, payload: Api.ListBatchesPayload) => readonly ["batches", string, {
+            workflowUuids?: string[] | undefined;
+            releaseUuid?: string | undefined;
+            parentBatchUuid?: string | undefined;
+            parentRunUuid?: string | undefined;
+            parentNodeUuid?: string | undefined;
+            statuses?: BatchStatus[] | undefined;
+            hasRuns?: boolean | undefined;
+            isSkipped?: boolean | undefined;
+            isFinished?: boolean | undefined;
+            includedDataKinds?: ("filter" | "schedule" | "runs" | "records" | "segment" | "file" | "change" | "recordIds" | "group" | "form" | "watchedRecords")[] | undefined;
+            excludedDataKinds?: ("filter" | "schedule" | "runs" | "records" | "segment" | "file" | "change" | "recordIds" | "group" | "form" | "watchedRecords")[] | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+        }];
+    };
+    const workflowKeys: {
+        all: (workspaceUuid: string) => readonly ["workflows", string];
+    };
+    const playKeys: {
+        all: (workspaceUuid: string) => readonly ["plays", string];
+    };
+    const toolsKeys: {
+        all: (workspaceUuid: string) => readonly ["tools", string];
+    };
+    const releaseKeys: {
+        all: (workspaceUuid: string) => readonly ["releases", string];
+        get: (workspaceUuid: string, uuid: string) => readonly ["releases", string, string];
+        getDraft: (workspaceUuid: string, workflowUuid: string) => readonly ["releases", string, string];
+        list: (workspaceUuid: string, payload: Api.ListReleasesPayload) => readonly ["releases", string, {
+            workflowUuid?: string | undefined;
+            userUuid?: string | undefined;
+            statuses?: ReleaseStatus[] | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+        }];
+    };
+    const draftReleaseKeys: {
+        all: (workspaceUuid: string) => readonly ["draftReleases", string];
+        get: (workspaceUuid: string, workflowUuid: string) => readonly ["releases", string, string];
+    };
+    const runKeys: {
+        all: (workspaceUuid: string) => readonly ["runs", string];
+        get: (workspaceUuid: string, uuid: string) => readonly ["runs", string, string];
+        list: (workspaceUuid: string, payload: Api.ListRunsPayload) => readonly ["runs", string, {
+            workflowUuid: string;
+            batchUuid?: string | undefined;
+            releaseUuid?: string | undefined;
+            statuses?: RunStatus[] | undefined;
+            parentBatchUuid?: string | undefined;
+            parentUuid?: string | undefined;
+            parentNodeUuid?: string | undefined;
+            isGroupParent?: boolean | undefined;
+            recordId?: string | undefined;
+            recordTitle?: string | undefined;
+            recordTitleOrId?: string | undefined;
+            isFinished?: boolean | undefined;
+            executionsFilter?: {
+                conjonction: OrchestrationTypes.ExecutionsFilterConjonction;
+                groups: {
+                    conjonction: OrchestrationTypes.ExecutionsFilterConjonction;
+                    conditions: ({
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "isRunning";
+                    } | {
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "hasSuccess";
+                        value?: string | undefined;
+                    } | {
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "hasError";
+                        value?: string | undefined;
+                    })[];
+                }[];
+            } | undefined;
+            createdAfter?: string | undefined;
+            createdBefore?: string | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+        }];
+        count: (workspaceUuid: string, payload: Api.CountRunsPayload) => readonly ["runs", string, {
+            workflowUuid: string;
+            batchUuid?: string | undefined;
+            releaseUuid?: string | undefined;
+            statuses?: RunStatus[] | undefined;
+            parentBatchUuid?: string | undefined;
+            parentUuid?: string | undefined;
+            parentNodeUuid?: string | undefined;
+            isGroupParent?: boolean | undefined;
+            recordId?: string | undefined;
+            recordTitle?: string | undefined;
+            recordTitleOrId?: string | undefined;
+            isFinished?: boolean | undefined;
+            executionsFilter?: {
+                conjonction: OrchestrationTypes.ExecutionsFilterConjonction;
+                groups: {
+                    conjonction: OrchestrationTypes.ExecutionsFilterConjonction;
+                    conditions: ({
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "isRunning";
+                    } | {
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "hasSuccess";
+                        value?: string | undefined;
+                    } | {
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "hasError";
+                        value?: string | undefined;
+                    })[];
+                }[];
+            } | undefined;
+            createdAfter?: string | undefined;
+            createdBefore?: string | undefined;
+        }];
+        getMetrics: (workspaceUuid: string, payload: Api.GetRunMetricsPayload) => readonly ["runs", string, {
+            workflowUuid: string;
+            releaseUuid?: string | undefined;
+            batchUuid?: string | undefined;
+            createdAfter?: string | undefined;
+            createdBefore?: string | undefined;
+        }];
+    };
+    const recordKeys: {
+        all: (workspaceUuid: string) => readonly ["records", string];
+        list: (workspaceUuid: string, payload: Api.ListRecordsPayload) => readonly ["records", string, {
+            workflowUuid: string;
+            ids?: string[] | undefined;
+            title?: string | undefined;
+            titleOrId?: string | undefined;
+            releaseUuid?: string | undefined;
+            batchUuid?: string | undefined;
+            statuses?: RecordStatus[] | undefined;
+            parentBatchUuid?: string | undefined;
+            parentRunUuid?: string | undefined;
+            parentNodeUuid?: string | undefined;
+            isGroupParent?: boolean | undefined;
+            executionsFilter?: {
+                conjonction: OrchestrationTypes.ExecutionsFilterConjonction;
+                groups: {
+                    conjonction: OrchestrationTypes.ExecutionsFilterConjonction;
+                    conditions: ({
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "isRunning";
+                    } | {
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "hasSuccess";
+                        value?: string | undefined;
+                    } | {
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "hasError";
+                        value?: string | undefined;
+                    })[];
+                }[];
+            } | undefined;
+            createdAfter?: string | undefined;
+            createdBefore?: string | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+        }];
+        count: (workspaceUuid: string, payload: Api.CountRecordsPayload) => readonly ["records", string, {
+            workflowUuid: string;
+            ids?: string[] | undefined;
+            title?: string | undefined;
+            titleOrId?: string | undefined;
+            releaseUuid?: string | undefined;
+            batchUuid?: string | undefined;
+            statuses?: RecordStatus[] | undefined;
+            parentBatchUuid?: string | undefined;
+            parentRunUuid?: string | undefined;
+            parentNodeUuid?: string | undefined;
+            isGroupParent?: boolean | undefined;
+            executionsFilter?: {
+                conjonction: OrchestrationTypes.ExecutionsFilterConjonction;
+                groups: {
+                    conjonction: OrchestrationTypes.ExecutionsFilterConjonction;
+                    conditions: ({
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "isRunning";
+                    } | {
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "hasSuccess";
+                        value?: string | undefined;
+                    } | {
+                        kind: "node";
+                        nodeSlug: string;
+                        operator: "hasError";
+                        value?: string | undefined;
+                    })[];
+                }[];
+            } | undefined;
+            createdAfter?: string | undefined;
+            createdBefore?: string | undefined;
+        }];
+        getMetrics: (workspaceUuid: string, payload: Api.GetRecordMetricsPayload) => readonly ["records", string, {
+            workflowUuid: string;
+            releaseUuid?: string | undefined;
+            batchUuid?: string | undefined;
+            createdAfter?: string | undefined;
+            createdBefore?: string | undefined;
+        }];
+    };
+    const templateKeys: {
+        all: () => readonly ["templates"];
+        get: (slug: string) => readonly ["templates", string];
+        list: () => readonly ["templates"];
+    };
+}
+export interface OrchestrationSlice {
+    workflows: Orchestration.Workflow[];
+    setWorkflows: (workflows: Orchestration.Workflow[]) => void;
+    plays: Orchestration.Play[];
+    setPlays: (plays: Orchestration.Play[]) => void;
+    tools: Orchestration.Tool[];
+    setTools: (plays: Orchestration.Tool[]) => void;
+    templates: Array<Orchestration.Template | Ai.Template>;
+    setTemplates: (templates: Array<Orchestration.Template | Ai.Template>) => void;
+}
+export declare const createOrchestrationSlice: StateCreator<OrchestrationSlice, [
+], [
+], OrchestrationSlice>;
+export {};
+//# sourceMappingURL=orchestration.d.ts.map