@ailu-ai/contracts 2.0.0

package/dist/graphs.d.ts

@@ -0,0 +1,951 @@
+import { z } from "zod";
+export declare const NodeTypeSchema: z.ZodEnum<["action", "agent", "tool", "human-gate", "subgraph"]>;
+export declare const EdgeTypeSchema: z.ZodEnum<["default", "conditional"]>;
+declare const NodeDefinitionDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["action", "agent", "tool", "human-gate", "subgraph"]>;
+    label: z.ZodString;
+    subgraphId: z.ZodOptional<z.ZodString>;
+    inputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    outputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    fanOut: z.ZodOptional<z.ZodObject<{
+        parallelTo: z.ZodArray<z.ZodString, "many">;
+        joinAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        parallelTo: string[];
+        joinAt: string;
+    }, {
+        parallelTo: string[];
+        joinAt: string;
+    }>>;
+    retryPolicy: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodNumber;
+        backoffMs: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts: number;
+        backoffMs: number;
+    }, {
+        maxAttempts: number;
+        backoffMs: number;
+    }>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+    id: string;
+    label: string;
+    subgraphId?: string | undefined;
+    inputMapping?: Record<string, string> | undefined;
+    outputMapping?: Record<string, string> | undefined;
+    fanOut?: {
+        parallelTo: string[];
+        joinAt: string;
+    } | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        backoffMs: number;
+    } | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+    id: string;
+    label: string;
+    subgraphId?: string | undefined;
+    inputMapping?: Record<string, string> | undefined;
+    outputMapping?: Record<string, string> | undefined;
+    fanOut?: {
+        parallelTo: string[];
+        joinAt: string;
+    } | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        backoffMs: number;
+    } | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+declare const EdgeDefinitionDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    type: z.ZodEnum<["default", "conditional"]>;
+    condition: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "default" | "conditional";
+    to: string;
+    id: string;
+    from: string;
+    condition?: string | undefined;
+}, {
+    type: "default" | "conditional";
+    to: string;
+    id: string;
+    from: string;
+    condition?: string | undefined;
+}>;
+declare const ChannelDefinitionDtoSchema: z.ZodObject<{
+    type: z.ZodString;
+    reducer: z.ZodEnum<["replace", "append", "merge"]>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    /** ADR 0032: never emit this channel's value in run events/logs (masked; still checkpointed). */
+    noLog: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    reducer: "replace" | "append" | "merge";
+    default?: unknown;
+    noLog?: boolean | undefined;
+}, {
+    type: string;
+    reducer: "replace" | "append" | "merge";
+    default?: unknown;
+    noLog?: boolean | undefined;
+}>;
+declare const ChannelsDtoSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodString;
+    reducer: z.ZodEnum<["replace", "append", "merge"]>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    /** ADR 0032: never emit this channel's value in run events/logs (masked; still checkpointed). */
+    noLog: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    reducer: "replace" | "append" | "merge";
+    default?: unknown;
+    noLog?: boolean | undefined;
+}, {
+    type: string;
+    reducer: "replace" | "append" | "merge";
+    default?: unknown;
+    noLog?: boolean | undefined;
+}>>;
+export declare const CreateGraphDtoSchema: z.ZodObject<{
+    version: z.ZodString;
+    name: z.ZodString;
+    recursionLimit: z.ZodOptional<z.ZodNumber>;
+    channels: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        reducer: z.ZodEnum<["replace", "append", "merge"]>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        /** ADR 0032: never emit this channel's value in run events/logs (masked; still checkpointed). */
+        noLog: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }>>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["action", "agent", "tool", "human-gate", "subgraph"]>;
+        label: z.ZodString;
+        subgraphId: z.ZodOptional<z.ZodString>;
+        inputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        outputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        fanOut: z.ZodOptional<z.ZodObject<{
+            parallelTo: z.ZodArray<z.ZodString, "many">;
+            joinAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            parallelTo: string[];
+            joinAt: string;
+        }, {
+            parallelTo: string[];
+            joinAt: string;
+        }>>;
+        retryPolicy: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodNumber;
+            backoffMs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            maxAttempts: number;
+            backoffMs: number;
+        }, {
+            maxAttempts: number;
+            backoffMs: number;
+        }>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<["default", "conditional"]>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }, {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }>, "many">;
+    entryNodeId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    channels: Record<string, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }>;
+    nodes: {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    edges: {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }[];
+    entryNodeId: string;
+    metadata?: Record<string, unknown> | undefined;
+    recursionLimit?: number | undefined;
+}, {
+    name: string;
+    version: string;
+    channels: Record<string, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }>;
+    nodes: {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    edges: {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }[];
+    entryNodeId: string;
+    metadata?: Record<string, unknown> | undefined;
+    recursionLimit?: number | undefined;
+}>;
+export declare const GraphDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    recursionLimit: z.ZodOptional<z.ZodNumber>;
+    channels: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        reducer: z.ZodEnum<["replace", "append", "merge"]>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        /** ADR 0032: never emit this channel's value in run events/logs (masked; still checkpointed). */
+        noLog: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }>>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["action", "agent", "tool", "human-gate", "subgraph"]>;
+        label: z.ZodString;
+        subgraphId: z.ZodOptional<z.ZodString>;
+        inputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        outputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        fanOut: z.ZodOptional<z.ZodObject<{
+            parallelTo: z.ZodArray<z.ZodString, "many">;
+            joinAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            parallelTo: string[];
+            joinAt: string;
+        }, {
+            parallelTo: string[];
+            joinAt: string;
+        }>>;
+        retryPolicy: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodNumber;
+            backoffMs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            maxAttempts: number;
+            backoffMs: number;
+        }, {
+            maxAttempts: number;
+            backoffMs: number;
+        }>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<["default", "conditional"]>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }, {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }>, "many">;
+    entryNodeId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Owning tenant (tenancy). Optional for pre-tenancy rows backfilled to `default`. */
+    tenantId: z.ZodOptional<z.ZodString>;
+    /** Id of the principal who created the graph. */
+    createdBy: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    version: string;
+    channels: Record<string, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }>;
+    nodes: {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    edges: {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }[];
+    entryNodeId: string;
+    tenantId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    recursionLimit?: number | undefined;
+    createdBy?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    version: string;
+    channels: Record<string, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }>;
+    nodes: {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    edges: {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }[];
+    entryNodeId: string;
+    tenantId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    recursionLimit?: number | undefined;
+    createdBy?: string | undefined;
+}>;
+export type NodeTypeDto = z.infer<typeof NodeTypeSchema>;
+export type EdgeTypeDto = z.infer<typeof EdgeTypeSchema>;
+export type NodeDefinitionDto = z.infer<typeof NodeDefinitionDtoSchema>;
+export type EdgeDefinitionDto = z.infer<typeof EdgeDefinitionDtoSchema>;
+export type ChannelDefinitionDto = z.infer<typeof ChannelDefinitionDtoSchema>;
+export type ChannelsDto = z.infer<typeof ChannelsDtoSchema>;
+export type CreateGraphDto = z.infer<typeof CreateGraphDtoSchema>;
+export type GraphDto = z.infer<typeof GraphDtoSchema>;
+/**
+ * The serializable graph shape an example graph carries. Wire-compatible with the
+ * engine `GraphDefinition` (version / name / channels / nodes / edges / entryNodeId),
+ * carrying everything the Studio's reactflow preview and create-graph flow need —
+ * without the Studio ever importing the engine or the SDK. The `id` is optional
+ * because example definitions are authored in code, not yet persisted.
+ */
+export declare const ExampleGraphDefinitionDtoSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    version: z.ZodString;
+    name: z.ZodString;
+    recursionLimit: z.ZodOptional<z.ZodNumber>;
+    channels: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        reducer: z.ZodEnum<["replace", "append", "merge"]>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        /** ADR 0032: never emit this channel's value in run events/logs (masked; still checkpointed). */
+        noLog: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }>>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["action", "agent", "tool", "human-gate", "subgraph"]>;
+        label: z.ZodString;
+        subgraphId: z.ZodOptional<z.ZodString>;
+        inputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        outputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        fanOut: z.ZodOptional<z.ZodObject<{
+            parallelTo: z.ZodArray<z.ZodString, "many">;
+            joinAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            parallelTo: string[];
+            joinAt: string;
+        }, {
+            parallelTo: string[];
+            joinAt: string;
+        }>>;
+        retryPolicy: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodNumber;
+            backoffMs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            maxAttempts: number;
+            backoffMs: number;
+        }, {
+            maxAttempts: number;
+            backoffMs: number;
+        }>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<["default", "conditional"]>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }, {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }>, "many">;
+    entryNodeId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    channels: Record<string, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }>;
+    nodes: {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    edges: {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }[];
+    entryNodeId: string;
+    id?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    recursionLimit?: number | undefined;
+}, {
+    name: string;
+    version: string;
+    channels: Record<string, {
+        type: string;
+        reducer: "replace" | "append" | "merge";
+        default?: unknown;
+        noLog?: boolean | undefined;
+    }>;
+    nodes: {
+        type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+        id: string;
+        label: string;
+        subgraphId?: string | undefined;
+        inputMapping?: Record<string, string> | undefined;
+        outputMapping?: Record<string, string> | undefined;
+        fanOut?: {
+            parallelTo: string[];
+            joinAt: string;
+        } | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    edges: {
+        type: "default" | "conditional";
+        to: string;
+        id: string;
+        from: string;
+        condition?: string | undefined;
+    }[];
+    entryNodeId: string;
+    id?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    recursionLimit?: number | undefined;
+}>;
+/**
+ * One example graph authored with `@ailu-ai/graph-sdk` and served by the control
+ * plane so the (commercial) Studio can render it — a name/description, plus the
+ * plain `definition` for the reactflow preview and the import-into-control-plane flow.
+ */
+export declare const ExampleGraphDtoSchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    definition: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        version: z.ZodString;
+        name: z.ZodString;
+        recursionLimit: z.ZodOptional<z.ZodNumber>;
+        channels: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodString;
+            reducer: z.ZodEnum<["replace", "append", "merge"]>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            /** ADR 0032: never emit this channel's value in run events/logs (masked; still checkpointed). */
+            noLog: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            reducer: "replace" | "append" | "merge";
+            default?: unknown;
+            noLog?: boolean | undefined;
+        }, {
+            type: string;
+            reducer: "replace" | "append" | "merge";
+            default?: unknown;
+            noLog?: boolean | undefined;
+        }>>;
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<["action", "agent", "tool", "human-gate", "subgraph"]>;
+            label: z.ZodString;
+            subgraphId: z.ZodOptional<z.ZodString>;
+            inputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            outputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            fanOut: z.ZodOptional<z.ZodObject<{
+                parallelTo: z.ZodArray<z.ZodString, "many">;
+                joinAt: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                parallelTo: string[];
+                joinAt: string;
+            }, {
+                parallelTo: string[];
+                joinAt: string;
+            }>>;
+            retryPolicy: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodNumber;
+                backoffMs: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                maxAttempts: number;
+                backoffMs: number;
+            }, {
+                maxAttempts: number;
+                backoffMs: number;
+            }>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+            id: string;
+            label: string;
+            subgraphId?: string | undefined;
+            inputMapping?: Record<string, string> | undefined;
+            outputMapping?: Record<string, string> | undefined;
+            fanOut?: {
+                parallelTo: string[];
+                joinAt: string;
+            } | undefined;
+            retryPolicy?: {
+                maxAttempts: number;
+                backoffMs: number;
+            } | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }, {
+            type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+            id: string;
+            label: string;
+            subgraphId?: string | undefined;
+            inputMapping?: Record<string, string> | undefined;
+            outputMapping?: Record<string, string> | undefined;
+            fanOut?: {
+                parallelTo: string[];
+                joinAt: string;
+            } | undefined;
+            retryPolicy?: {
+                maxAttempts: number;
+                backoffMs: number;
+            } | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }>, "many">;
+        edges: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            type: z.ZodEnum<["default", "conditional"]>;
+            condition: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "default" | "conditional";
+            to: string;
+            id: string;
+            from: string;
+            condition?: string | undefined;
+        }, {
+            type: "default" | "conditional";
+            to: string;
+            id: string;
+            from: string;
+            condition?: string | undefined;
+        }>, "many">;
+        entryNodeId: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: string;
+        channels: Record<string, {
+            type: string;
+            reducer: "replace" | "append" | "merge";
+            default?: unknown;
+            noLog?: boolean | undefined;
+        }>;
+        nodes: {
+            type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+            id: string;
+            label: string;
+            subgraphId?: string | undefined;
+            inputMapping?: Record<string, string> | undefined;
+            outputMapping?: Record<string, string> | undefined;
+            fanOut?: {
+                parallelTo: string[];
+                joinAt: string;
+            } | undefined;
+            retryPolicy?: {
+                maxAttempts: number;
+                backoffMs: number;
+            } | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }[];
+        edges: {
+            type: "default" | "conditional";
+            to: string;
+            id: string;
+            from: string;
+            condition?: string | undefined;
+        }[];
+        entryNodeId: string;
+        id?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        recursionLimit?: number | undefined;
+    }, {
+        name: string;
+        version: string;
+        channels: Record<string, {
+            type: string;
+            reducer: "replace" | "append" | "merge";
+            default?: unknown;
+            noLog?: boolean | undefined;
+        }>;
+        nodes: {
+            type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+            id: string;
+            label: string;
+            subgraphId?: string | undefined;
+            inputMapping?: Record<string, string> | undefined;
+            outputMapping?: Record<string, string> | undefined;
+            fanOut?: {
+                parallelTo: string[];
+                joinAt: string;
+            } | undefined;
+            retryPolicy?: {
+                maxAttempts: number;
+                backoffMs: number;
+            } | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }[];
+        edges: {
+            type: "default" | "conditional";
+            to: string;
+            id: string;
+            from: string;
+            condition?: string | undefined;
+        }[];
+        entryNodeId: string;
+        id?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        recursionLimit?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    slug: string;
+    description: string;
+    definition: {
+        name: string;
+        version: string;
+        channels: Record<string, {
+            type: string;
+            reducer: "replace" | "append" | "merge";
+            default?: unknown;
+            noLog?: boolean | undefined;
+        }>;
+        nodes: {
+            type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+            id: string;
+            label: string;
+            subgraphId?: string | undefined;
+            inputMapping?: Record<string, string> | undefined;
+            outputMapping?: Record<string, string> | undefined;
+            fanOut?: {
+                parallelTo: string[];
+                joinAt: string;
+            } | undefined;
+            retryPolicy?: {
+                maxAttempts: number;
+                backoffMs: number;
+            } | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }[];
+        edges: {
+            type: "default" | "conditional";
+            to: string;
+            id: string;
+            from: string;
+            condition?: string | undefined;
+        }[];
+        entryNodeId: string;
+        id?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        recursionLimit?: number | undefined;
+    };
+}, {
+    name: string;
+    slug: string;
+    description: string;
+    definition: {
+        name: string;
+        version: string;
+        channels: Record<string, {
+            type: string;
+            reducer: "replace" | "append" | "merge";
+            default?: unknown;
+            noLog?: boolean | undefined;
+        }>;
+        nodes: {
+            type: "action" | "agent" | "tool" | "human-gate" | "subgraph";
+            id: string;
+            label: string;
+            subgraphId?: string | undefined;
+            inputMapping?: Record<string, string> | undefined;
+            outputMapping?: Record<string, string> | undefined;
+            fanOut?: {
+                parallelTo: string[];
+                joinAt: string;
+            } | undefined;
+            retryPolicy?: {
+                maxAttempts: number;
+                backoffMs: number;
+            } | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }[];
+        edges: {
+            type: "default" | "conditional";
+            to: string;
+            id: string;
+            from: string;
+            condition?: string | undefined;
+        }[];
+        entryNodeId: string;
+        id?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        recursionLimit?: number | undefined;
+    };
+}>;
+export type ExampleGraphDefinitionDto = z.infer<typeof ExampleGraphDefinitionDtoSchema>;
+export type ExampleGraphDto = z.infer<typeof ExampleGraphDtoSchema>;
+export {};
+//# sourceMappingURL=graphs.d.ts.map