@ailu-ai/contracts 2.0.0

package/dist/catalog.d.ts

@@ -0,0 +1,626 @@
+import { z } from "zod";
+/**
+ * The component / prebuilt-agent / model-tier catalog contract: the shape the API
+ * serves so Studio can render the building-block library without importing the engine
+ * or the SDK. The SDK owns the source metadata (`@ailu-ai/graph-sdk` `catalog`); the
+ * API validates it against these schemas and forwards it unchanged.
+ */
+/** A single parameter a component factory accepts. */
+export declare const ComponentParamDtoSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    required: z.ZodBoolean;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    name: string;
+    required: boolean;
+    description: string;
+}, {
+    type: string;
+    name: string;
+    required: boolean;
+    description: string;
+}>;
+/** The category buckets a component falls into in the library. */
+export declare const ComponentCategoryDtoSchema: z.ZodEnum<["prompt", "validation", "parsing", "routing", "retrieval", "text", "data", "integration", "splitter", "generation", "evaluation", "writer"]>;
+/** One entry in the component library: a `kind` plus its presentation + params. */
+export declare const ComponentCatalogEntryDtoSchema: z.ZodObject<{
+    kind: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodEnum<["prompt", "validation", "parsing", "routing", "retrieval", "text", "data", "integration", "splitter", "generation", "evaluation", "writer"]>;
+    description: z.ZodString;
+    params: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        name: string;
+        required: boolean;
+        description: string;
+    }, {
+        type: string;
+        name: string;
+        required: boolean;
+        description: string;
+    }>, "many">;
+    /** `true` for vendor-I/O integration components (httpFetch / webSearch). */
+    integration: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        type: string;
+        name: string;
+        required: boolean;
+        description: string;
+    }[];
+    description: string;
+    integration: boolean;
+    kind: string;
+    title: string;
+    category: "validation" | "prompt" | "parsing" | "routing" | "retrieval" | "text" | "data" | "integration" | "splitter" | "generation" | "evaluation" | "writer";
+}, {
+    params: {
+        type: string;
+        name: string;
+        required: boolean;
+        description: string;
+    }[];
+    description: string;
+    integration: boolean;
+    kind: string;
+    title: string;
+    category: "validation" | "prompt" | "parsing" | "routing" | "retrieval" | "text" | "data" | "integration" | "splitter" | "generation" | "evaluation" | "writer";
+}>;
+/** The four capability tiers, wire-compatible (camelCase) with the engine `ModelTier`. */
+export declare const ModelTierDtoSchema: z.ZodEnum<["frontier", "balanced", "fast", "creative"]>;
+/** One entry in the prebuilt-agent catalog, mirroring the Rust `PrebuiltAgent` table. */
+export declare const PrebuiltAgentCatalogEntryDtoSchema: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    tier: z.ZodEnum<["frontier", "balanced", "fast", "creative"]>;
+    tools: z.ZodArray<z.ZodString, "many">;
+    suspendForApproval: z.ZodBoolean;
+    outputChannel: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    title: string;
+    tier: "frontier" | "balanced" | "fast" | "creative";
+    tools: string[];
+    suspendForApproval: boolean;
+    outputChannel: string;
+}, {
+    name: string;
+    description: string;
+    title: string;
+    tier: "frontier" | "balanced" | "fast" | "creative";
+    tools: string[];
+    suspendForApproval: boolean;
+    outputChannel: string;
+}>;
+/** Describes one capability tier plus its recommended per-provider models. */
+export declare const ModelTierInfoDtoSchema: z.ZodObject<{
+    tier: z.ZodEnum<["frontier", "balanced", "fast", "creative"]>;
+    description: z.ZodString;
+    /** `provider -> model` recommended defaults for this tier. */
+    models: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    tier: "frontier" | "balanced" | "fast" | "creative";
+    models: Record<string, string>;
+}, {
+    description: string;
+    tier: "frontier" | "balanced" | "fast" | "creative";
+    models: Record<string, string>;
+}>;
+/** The full catalog the API serves to Studio. */
+export declare const CatalogDtoSchema: z.ZodObject<{
+    components: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        title: z.ZodString;
+        category: z.ZodEnum<["prompt", "validation", "parsing", "routing", "retrieval", "text", "data", "integration", "splitter", "generation", "evaluation", "writer"]>;
+        description: z.ZodString;
+        params: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            required: z.ZodBoolean;
+            description: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            name: string;
+            required: boolean;
+            description: string;
+        }, {
+            type: string;
+            name: string;
+            required: boolean;
+            description: string;
+        }>, "many">;
+        /** `true` for vendor-I/O integration components (httpFetch / webSearch). */
+        integration: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        params: {
+            type: string;
+            name: string;
+            required: boolean;
+            description: string;
+        }[];
+        description: string;
+        integration: boolean;
+        kind: string;
+        title: string;
+        category: "validation" | "prompt" | "parsing" | "routing" | "retrieval" | "text" | "data" | "integration" | "splitter" | "generation" | "evaluation" | "writer";
+    }, {
+        params: {
+            type: string;
+            name: string;
+            required: boolean;
+            description: string;
+        }[];
+        description: string;
+        integration: boolean;
+        kind: string;
+        title: string;
+        category: "validation" | "prompt" | "parsing" | "routing" | "retrieval" | "text" | "data" | "integration" | "splitter" | "generation" | "evaluation" | "writer";
+    }>, "many">;
+    prebuilt: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        tier: z.ZodEnum<["frontier", "balanced", "fast", "creative"]>;
+        tools: z.ZodArray<z.ZodString, "many">;
+        suspendForApproval: z.ZodBoolean;
+        outputChannel: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        title: string;
+        tier: "frontier" | "balanced" | "fast" | "creative";
+        tools: string[];
+        suspendForApproval: boolean;
+        outputChannel: string;
+    }, {
+        name: string;
+        description: string;
+        title: string;
+        tier: "frontier" | "balanced" | "fast" | "creative";
+        tools: string[];
+        suspendForApproval: boolean;
+        outputChannel: string;
+    }>, "many">;
+    tiers: z.ZodArray<z.ZodObject<{
+        tier: z.ZodEnum<["frontier", "balanced", "fast", "creative"]>;
+        description: z.ZodString;
+        /** `provider -> model` recommended defaults for this tier. */
+        models: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        tier: "frontier" | "balanced" | "fast" | "creative";
+        models: Record<string, string>;
+    }, {
+        description: string;
+        tier: "frontier" | "balanced" | "fast" | "creative";
+        models: Record<string, string>;
+    }>, "many">;
+    /** SDK-authored example graphs, served so Studio can render + import them. */
+    exampleGraphs: z.ZodArray<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>;
+                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;
+        };
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    components: {
+        params: {
+            type: string;
+            name: string;
+            required: boolean;
+            description: string;
+        }[];
+        description: string;
+        integration: boolean;
+        kind: string;
+        title: string;
+        category: "validation" | "prompt" | "parsing" | "routing" | "retrieval" | "text" | "data" | "integration" | "splitter" | "generation" | "evaluation" | "writer";
+    }[];
+    prebuilt: {
+        name: string;
+        description: string;
+        title: string;
+        tier: "frontier" | "balanced" | "fast" | "creative";
+        tools: string[];
+        suspendForApproval: boolean;
+        outputChannel: string;
+    }[];
+    tiers: {
+        description: string;
+        tier: "frontier" | "balanced" | "fast" | "creative";
+        models: Record<string, string>;
+    }[];
+    exampleGraphs: {
+        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;
+        };
+    }[];
+}, {
+    components: {
+        params: {
+            type: string;
+            name: string;
+            required: boolean;
+            description: string;
+        }[];
+        description: string;
+        integration: boolean;
+        kind: string;
+        title: string;
+        category: "validation" | "prompt" | "parsing" | "routing" | "retrieval" | "text" | "data" | "integration" | "splitter" | "generation" | "evaluation" | "writer";
+    }[];
+    prebuilt: {
+        name: string;
+        description: string;
+        title: string;
+        tier: "frontier" | "balanced" | "fast" | "creative";
+        tools: string[];
+        suspendForApproval: boolean;
+        outputChannel: string;
+    }[];
+    tiers: {
+        description: string;
+        tier: "frontier" | "balanced" | "fast" | "creative";
+        models: Record<string, string>;
+    }[];
+    exampleGraphs: {
+        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 ComponentParamDto = z.infer<typeof ComponentParamDtoSchema>;
+export type ComponentCategoryDto = z.infer<typeof ComponentCategoryDtoSchema>;
+export type ComponentCatalogEntryDto = z.infer<typeof ComponentCatalogEntryDtoSchema>;
+export type ModelTierDto = z.infer<typeof ModelTierDtoSchema>;
+export type PrebuiltAgentCatalogEntryDto = z.infer<typeof PrebuiltAgentCatalogEntryDtoSchema>;
+export type ModelTierInfoDto = z.infer<typeof ModelTierInfoDtoSchema>;
+export type CatalogDto = z.infer<typeof CatalogDtoSchema>;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;GAKG;AAEH,sDAAsD;AACtD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;EAKlC,CAAC;AAEH,kEAAkE;AAClE,eAAO,MAAM,0BAA0B,yJAcrC,CAAC;AAEH,mFAAmF;AACnF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;IAMzC,4EAA4E;;;;;;;;;;;;;;;;;;;;;;;;;;EAE5E,CAAC;AAEH,0FAA0F;AAC1F,eAAO,MAAM,kBAAkB,yDAAuD,CAAC;AAEvF,yFAAyF;AACzF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;EAQ7C,CAAC;AAEH,8EAA8E;AAC9E,eAAO,MAAM,sBAAsB;;;IAGjC,8DAA8D;;;;;;;;;;EAE9D,CAAC;AAEH,iDAAiD;AACjD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;QA3B3B,4EAA4E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsB5E,8DAA8D;;;;;;;;;;;IAS9D,8EAA8E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9E,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAC9F,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}