@bubblelab/shared-schemas 0.1.0

package/dist/bubble-definition-schema.js

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import { CredentialType } from './types';
+// Bubble parameter type enum
+export var BubbleParameterType;
+(function (BubbleParameterType) {
+    BubbleParameterType["STRING"] = "string";
+    BubbleParameterType["NUMBER"] = "number";
+    BubbleParameterType["BOOLEAN"] = "boolean";
+    BubbleParameterType["OBJECT"] = "object";
+    BubbleParameterType["ARRAY"] = "array";
+    BubbleParameterType["ENV"] = "env";
+    BubbleParameterType["VARIABLE"] = "variable";
+    BubbleParameterType["EXPRESSION"] = "expression";
+    BubbleParameterType["UNKNOWN"] = "unknown";
+})(BubbleParameterType || (BubbleParameterType = {}));
+// Credential configuration mappings - defines what configurations are available for each credential type
+export const CREDENTIAL_CONFIGURATION_MAP = {
+    [CredentialType.DATABASE_CRED]: {
+        ignoreSSL: BubbleParameterType.BOOLEAN,
+    },
+    [CredentialType.OPENAI_CRED]: {},
+    [CredentialType.GOOGLE_GEMINI_CRED]: {},
+    [CredentialType.ANTHROPIC_CRED]: {},
+    [CredentialType.FIRECRAWL_API_KEY]: {},
+    [CredentialType.SLACK_CRED]: {},
+    [CredentialType.RESEND_CRED]: {},
+    [CredentialType.OPENROUTER_CRED]: {},
+    [CredentialType.CLOUDFLARE_R2_ACCESS_KEY]: {},
+    [CredentialType.CLOUDFLARE_R2_SECRET_KEY]: {},
+    [CredentialType.CLOUDFLARE_R2_ACCOUNT_ID]: {},
+    [CredentialType.GOOGLE_DRIVE_CRED]: {},
+    [CredentialType.GMAIL_CRED]: {},
+    [CredentialType.GOOGLE_SHEETS_CRED]: {},
+    [CredentialType.GOOGLE_CALENDAR_CRED]: {},
+};
+// Fixed list of bubble names that need context injection
+export const BUBBLE_NAMES_WITH_CONTEXT_INJECTION = [
+    'database-analyzer',
+    'slack-data-assistant',
+];
+// Zod schemas for validation and type inference
+export const BubbleParameterTypeSchema = z.nativeEnum(BubbleParameterType);
+export const BubbleParameterSchema = z.object({
+    variableId: z.number().optional(),
+    name: z.string(),
+    value: z.unknown(),
+    type: BubbleParameterTypeSchema,
+});
+export const BubbleNodeTypeSchema = z.enum([
+    'service',
+    'tool',
+    'workflow',
+    'unknown',
+]);
+export const DependencyGraphNodeSchema = z.lazy(() => z.object({
+    name: z.string(),
+    variableName: z.string().optional(),
+    nodeType: BubbleNodeTypeSchema,
+    uniqueId: z.string().optional(),
+    variableId: z.number().optional(),
+    dependencies: z.array(DependencyGraphNodeSchema),
+}));
+export const ParsedBubbleSchema = z.object({
+    variableName: z.string(),
+    bubbleName: z.string(),
+    className: z.string(),
+    parameters: z.array(BubbleParameterSchema),
+    hasAwait: z.boolean(),
+    hasActionCall: z.boolean(),
+    dependencies: z.array(z.string()).optional(),
+    dependencyGraph: DependencyGraphNodeSchema.optional(),
+});
+export const BubbleDependencySpecSchema = z.object({
+    name: z.string(),
+    tools: z.array(z.string()).optional(),
+});
+export const ParsedBubbleWithInfoSchema = z.object({
+    variableName: z.string(),
+    bubbleName: z.string(),
+    className: z.string(),
+    parameters: z.array(BubbleParameterSchema),
+    hasAwait: z.boolean(),
+    hasActionCall: z.boolean(),
+    dependencies: z.array(z.string()).optional(),
+    dependencyGraph: DependencyGraphNodeSchema.optional(),
+    variableId: z.number(),
+    nodeType: BubbleNodeTypeSchema,
+    location: z.object({
+        startLine: z.number(),
+        startCol: z.number(),
+        endLine: z.number(),
+        endCol: z.number(),
+    }),
+});
+//# sourceMappingURL=bubble-definition-schema.js.map

package/dist/bubble-definition-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bubble-definition-schema.js","sourceRoot":"","sources":["../src/bubble-definition-schema.ts"],"names":[],"mappings":"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"}

package/dist/bubbleflow-execution-schema.d.ts

@@ -0,0 +1,580 @@
+import { z } from '@hono/zod-openapi';
+export declare const TokenUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+    modelName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    modelName?: string | undefined;
+}, {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    modelName?: string | undefined;
+}>;
+export type TokenUsage = z.infer<typeof TokenUsageSchema>;
+export declare const ExecutionSummarySchema: z.ZodObject<{
+    totalDuration: z.ZodNumber;
+    lineExecutionCount: z.ZodNumber;
+    bubbleExecutionCount: z.ZodNumber;
+    errorCount: z.ZodNumber;
+    warningCount: z.ZodNumber;
+    averageLineExecutionTime: z.ZodNumber;
+    slowestLines: z.ZodArray<z.ZodObject<{
+        lineNumber: z.ZodNumber;
+        duration: z.ZodNumber;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        lineNumber: number;
+        duration: number;
+    }, {
+        message: string;
+        lineNumber: number;
+        duration: number;
+    }>, "many">;
+    memoryPeakUsage: z.ZodOptional<z.ZodAny>;
+    startTime: z.ZodNumber;
+    endTime: z.ZodNumber;
+    tokenUsage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+        modelName: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        modelName?: string | undefined;
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        modelName?: string | undefined;
+    }>;
+    tokenUsageByModel: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+        modelName: z.ZodOptional<z.ZodString>;
+    }, "modelName">, "strip", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    totalDuration: number;
+    lineExecutionCount: number;
+    bubbleExecutionCount: number;
+    errorCount: number;
+    warningCount: number;
+    averageLineExecutionTime: number;
+    slowestLines: {
+        message: string;
+        lineNumber: number;
+        duration: number;
+    }[];
+    startTime: number;
+    endTime: number;
+    tokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        modelName?: string | undefined;
+    };
+    memoryPeakUsage?: any;
+    tokenUsageByModel?: Record<string, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }> | undefined;
+}, {
+    totalDuration: number;
+    lineExecutionCount: number;
+    bubbleExecutionCount: number;
+    errorCount: number;
+    warningCount: number;
+    averageLineExecutionTime: number;
+    slowestLines: {
+        message: string;
+        lineNumber: number;
+        duration: number;
+    }[];
+    startTime: number;
+    endTime: number;
+    tokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        modelName?: string | undefined;
+    };
+    memoryPeakUsage?: any;
+    tokenUsageByModel?: Record<string, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }> | undefined;
+}>;
+export type ExecutionSummary = z.infer<typeof ExecutionSummarySchema>;
+export declare const bubbleFlowExecutionSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    status: z.ZodEnum<["running", "success", "error"]>;
+    payload: z.ZodRecord<z.ZodString, z.ZodAny>;
+    result: z.ZodOptional<z.ZodAny>;
+    error: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodString;
+    webhook_url: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "running" | "success" | "error";
+    id: number;
+    payload: Record<string, any>;
+    startedAt: string;
+    webhook_url: string;
+    error?: string | undefined;
+    result?: any;
+    completedAt?: string | undefined;
+}, {
+    status: "running" | "success" | "error";
+    id: number;
+    payload: Record<string, any>;
+    startedAt: string;
+    webhook_url: string;
+    error?: string | undefined;
+    result?: any;
+    completedAt?: string | undefined;
+}>;
+export declare const listBubbleFlowExecutionsResponseSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    status: z.ZodEnum<["running", "success", "error"]>;
+    payload: z.ZodRecord<z.ZodString, z.ZodAny>;
+    result: z.ZodOptional<z.ZodAny>;
+    error: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodString;
+    webhook_url: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "running" | "success" | "error";
+    id: number;
+    payload: Record<string, any>;
+    startedAt: string;
+    webhook_url: string;
+    error?: string | undefined;
+    result?: any;
+    completedAt?: string | undefined;
+}, {
+    status: "running" | "success" | "error";
+    id: number;
+    payload: Record<string, any>;
+    startedAt: string;
+    webhook_url: string;
+    error?: string | undefined;
+    result?: any;
+    completedAt?: string | undefined;
+}>, "many">;
+export type ListBubbleFlowExecutionsResponse = z.infer<typeof listBubbleFlowExecutionsResponseSchema>;
+export declare const executeBubbleFlowResponseSchema: z.ZodObject<{
+    executionId: z.ZodNumber;
+    success: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodAny>;
+    summary: z.ZodOptional<z.ZodObject<{
+        totalDuration: z.ZodNumber;
+        lineExecutionCount: z.ZodNumber;
+        bubbleExecutionCount: z.ZodNumber;
+        errorCount: z.ZodNumber;
+        warningCount: z.ZodNumber;
+        averageLineExecutionTime: z.ZodNumber;
+        slowestLines: z.ZodArray<z.ZodObject<{
+            lineNumber: z.ZodNumber;
+            duration: z.ZodNumber;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            lineNumber: number;
+            duration: number;
+        }, {
+            message: string;
+            lineNumber: number;
+            duration: number;
+        }>, "many">;
+        memoryPeakUsage: z.ZodOptional<z.ZodAny>;
+        startTime: z.ZodNumber;
+        endTime: z.ZodNumber;
+        tokenUsage: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            totalTokens: z.ZodNumber;
+            modelName: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            modelName?: string | undefined;
+        }, {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            modelName?: string | undefined;
+        }>;
+        tokenUsageByModel: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            totalTokens: z.ZodNumber;
+            modelName: z.ZodOptional<z.ZodString>;
+        }, "modelName">, "strip", z.ZodTypeAny, {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        }, {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        totalDuration: number;
+        lineExecutionCount: number;
+        bubbleExecutionCount: number;
+        errorCount: number;
+        warningCount: number;
+        averageLineExecutionTime: number;
+        slowestLines: {
+            message: string;
+            lineNumber: number;
+            duration: number;
+        }[];
+        startTime: number;
+        endTime: number;
+        tokenUsage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            modelName?: string | undefined;
+        };
+        memoryPeakUsage?: any;
+        tokenUsageByModel?: Record<string, {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        }> | undefined;
+    }, {
+        totalDuration: number;
+        lineExecutionCount: number;
+        bubbleExecutionCount: number;
+        errorCount: number;
+        warningCount: number;
+        averageLineExecutionTime: number;
+        slowestLines: {
+            message: string;
+            lineNumber: number;
+            duration: number;
+        }[];
+        startTime: number;
+        endTime: number;
+        tokenUsage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            modelName?: string | undefined;
+        };
+        memoryPeakUsage?: any;
+        tokenUsageByModel?: Record<string, {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        }> | undefined;
+    }>>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    executionId: number;
+    error?: string | undefined;
+    data?: any;
+    summary?: {
+        totalDuration: number;
+        lineExecutionCount: number;
+        bubbleExecutionCount: number;
+        errorCount: number;
+        warningCount: number;
+        averageLineExecutionTime: number;
+        slowestLines: {
+            message: string;
+            lineNumber: number;
+            duration: number;
+        }[];
+        startTime: number;
+        endTime: number;
+        tokenUsage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            modelName?: string | undefined;
+        };
+        memoryPeakUsage?: any;
+        tokenUsageByModel?: Record<string, {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        }> | undefined;
+    } | undefined;
+}, {
+    success: boolean;
+    executionId: number;
+    error?: string | undefined;
+    data?: any;
+    summary?: {
+        totalDuration: number;
+        lineExecutionCount: number;
+        bubbleExecutionCount: number;
+        errorCount: number;
+        warningCount: number;
+        averageLineExecutionTime: number;
+        slowestLines: {
+            message: string;
+            lineNumber: number;
+            duration: number;
+        }[];
+        startTime: number;
+        endTime: number;
+        tokenUsage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            modelName?: string | undefined;
+        };
+        memoryPeakUsage?: any;
+        tokenUsageByModel?: Record<string, {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        }> | undefined;
+    } | undefined;
+}>;
+export type ExecuteBubbleFlowResponse = z.infer<typeof executeBubbleFlowResponseSchema>;
+export type ExecutionResult = ExecuteBubbleFlowResponse;
+export declare const validateBubbleFlowCodeSchema: z.ZodObject<{
+    code: z.ZodString;
+    options: z.ZodOptional<z.ZodObject<{
+        includeDetails: z.ZodDefault<z.ZodBoolean>;
+        strictMode: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        includeDetails: boolean;
+        strictMode: boolean;
+    }, {
+        includeDetails?: boolean | undefined;
+        strictMode?: boolean | undefined;
+    }>>;
+    flowId: z.ZodOptional<z.ZodNumber>;
+    credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    options?: {
+        includeDetails: boolean;
+        strictMode: boolean;
+    } | undefined;
+    flowId?: number | undefined;
+    credentials?: Record<string, Record<string, number>> | undefined;
+}, {
+    code: string;
+    options?: {
+        includeDetails?: boolean | undefined;
+        strictMode?: boolean | undefined;
+    } | undefined;
+    flowId?: number | undefined;
+    credentials?: Record<string, Record<string, number>> | undefined;
+}>;
+export declare const validateBubbleFlowCodeResponseSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    bubbleCount: z.ZodOptional<z.ZodNumber>;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    bubbles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        variableName: z.ZodString;
+        bubbleName: z.ZodString;
+        className: z.ZodString;
+        parameters: z.ZodArray<z.ZodObject<{
+            variableId: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodString;
+            value: z.ZodUnknown;
+            type: z.ZodNativeEnum<typeof import("./bubble-definition-schema").BubbleParameterType>;
+        }, "strip", z.ZodTypeAny, {
+            type: import("./bubble-definition-schema").BubbleParameterType;
+            name: string;
+            value?: unknown;
+            variableId?: number | undefined;
+        }, {
+            type: import("./bubble-definition-schema").BubbleParameterType;
+            name: string;
+            value?: unknown;
+            variableId?: number | undefined;
+        }>, "many">;
+        hasAwait: z.ZodBoolean;
+        hasActionCall: z.ZodBoolean;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodType<import("./types").BubbleName, z.ZodTypeDef, import("./types").BubbleName>, "many">>;
+        dependencyGraph: z.ZodOptional<z.ZodType<import("./bubble-definition-schema").DependencyGraphNode, z.ZodTypeDef, import("./bubble-definition-schema").DependencyGraphNode>>;
+        variableId: z.ZodNumber;
+        nodeType: z.ZodEnum<["service", "tool", "workflow", "unknown"]>;
+        location: z.ZodObject<{
+            startLine: z.ZodNumber;
+            startCol: z.ZodNumber;
+            endLine: z.ZodNumber;
+            endCol: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            startLine: number;
+            startCol: number;
+            endLine: number;
+            endCol: number;
+        }, {
+            startLine: number;
+            startCol: number;
+            endLine: number;
+            endCol: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        variableName: string;
+        bubbleName: string;
+        className: string;
+        parameters: {
+            type: import("./bubble-definition-schema").BubbleParameterType;
+            name: string;
+            value?: unknown;
+            variableId?: number | undefined;
+        }[];
+        variableId: number;
+        hasAwait: boolean;
+        hasActionCall: boolean;
+        nodeType: "unknown" | "service" | "tool" | "workflow";
+        location: {
+            startLine: number;
+            startCol: number;
+            endLine: number;
+            endCol: number;
+        };
+        dependencies?: import("./types").BubbleName[] | undefined;
+        dependencyGraph?: import("./bubble-definition-schema").DependencyGraphNode | undefined;
+    }, {
+        variableName: string;
+        bubbleName: string;
+        className: string;
+        parameters: {
+            type: import("./bubble-definition-schema").BubbleParameterType;
+            name: string;
+            value?: unknown;
+            variableId?: number | undefined;
+        }[];
+        variableId: number;
+        hasAwait: boolean;
+        hasActionCall: boolean;
+        nodeType: "unknown" | "service" | "tool" | "workflow";
+        location: {
+            startLine: number;
+            startCol: number;
+            endLine: number;
+            endCol: number;
+        };
+        dependencies?: import("./types").BubbleName[] | undefined;
+        dependencyGraph?: import("./bubble-definition-schema").DependencyGraphNode | undefined;
+    }>>>;
+    requiredCredentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    metadata: z.ZodObject<{
+        validatedAt: z.ZodString;
+        codeLength: z.ZodNumber;
+        strictMode: z.ZodBoolean;
+        flowUpdated: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        strictMode: boolean;
+        validatedAt: string;
+        codeLength: number;
+        flowUpdated?: boolean | undefined;
+    }, {
+        strictMode: boolean;
+        validatedAt: string;
+        codeLength: number;
+        flowUpdated?: boolean | undefined;
+    }>;
+    success: z.ZodBoolean;
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    valid: boolean;
+    success: boolean;
+    error: string;
+    inputSchema: Record<string, unknown>;
+    metadata: {
+        strictMode: boolean;
+        validatedAt: string;
+        codeLength: number;
+        flowUpdated?: boolean | undefined;
+    };
+    errors?: string[] | undefined;
+    bubbleCount?: number | undefined;
+    bubbles?: Record<string, {
+        variableName: string;
+        bubbleName: string;
+        className: string;
+        parameters: {
+            type: import("./bubble-definition-schema").BubbleParameterType;
+            name: string;
+            value?: unknown;
+            variableId?: number | undefined;
+        }[];
+        variableId: number;
+        hasAwait: boolean;
+        hasActionCall: boolean;
+        nodeType: "unknown" | "service" | "tool" | "workflow";
+        location: {
+            startLine: number;
+            startCol: number;
+            endLine: number;
+            endCol: number;
+        };
+        dependencies?: import("./types").BubbleName[] | undefined;
+        dependencyGraph?: import("./bubble-definition-schema").DependencyGraphNode | undefined;
+    }> | undefined;
+    requiredCredentials?: Record<string, string[]> | undefined;
+}, {
+    valid: boolean;
+    success: boolean;
+    error: string;
+    inputSchema: Record<string, unknown>;
+    metadata: {
+        strictMode: boolean;
+        validatedAt: string;
+        codeLength: number;
+        flowUpdated?: boolean | undefined;
+    };
+    errors?: string[] | undefined;
+    bubbleCount?: number | undefined;
+    bubbles?: Record<string, {
+        variableName: string;
+        bubbleName: string;
+        className: string;
+        parameters: {
+            type: import("./bubble-definition-schema").BubbleParameterType;
+            name: string;
+            value?: unknown;
+            variableId?: number | undefined;
+        }[];
+        variableId: number;
+        hasAwait: boolean;
+        hasActionCall: boolean;
+        nodeType: "unknown" | "service" | "tool" | "workflow";
+        location: {
+            startLine: number;
+            startCol: number;
+            endLine: number;
+            endCol: number;
+        };
+        dependencies?: import("./types").BubbleName[] | undefined;
+        dependencyGraph?: import("./bubble-definition-schema").DependencyGraphNode | undefined;
+    }> | undefined;
+    requiredCredentials?: Record<string, string[]> | undefined;
+}>;
+export type ValidateBubbleFlowResponse = z.infer<typeof validateBubbleFlowCodeResponseSchema>;
+export type BubbleFlowExecution = z.infer<typeof bubbleFlowExecutionSchema>;
+//# sourceMappingURL=bubbleflow-execution-schema.d.ts.map

package/dist/bubbleflow-execution-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bubbleflow-execution-schema.d.ts","sourceRoot":"","sources":["../src/bubbleflow-execution-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAGtC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;EAmBL,CAAC;AAEzB,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0EL,CAAC;AAE/B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAGtE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBpC,CAAC;AAGH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;WAEL,CAAC;AAE/C,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBL,CAAC;AAExC,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAGF,MAAM,MAAM,eAAe,GAAG,yBAAyB,CAAC;AAGxD,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCvC,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+C/C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,oCAAoC,CAC5C,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}