syllable-sdk 1.0.14-rc.1 → 1.0.14-rc.3

package/src/models/components/context.ts

@@ -31,48 +31,34 @@ import {
   StepsTask$outboundSchema,
 } from "./stepstask.js";
 
-export type Two =
-  | (LoadToolFromFileTask & { type: "import" })
-  | (EventTask & { type: "event" })
-  | (ExpressionTask & { type: "expression" })
-  | (StepsTask & { type: "steps" });
+export type Two = EventTask | ExpressionTask | LoadToolFromFileTask | StepsTask;
 
 export type Task1 =
-  | (LoadToolFromFileTask & { type: "import" })
-  | (EventTask & { type: "event" })
-  | (ExpressionTask & { type: "expression" })
-  | (StepsTask & { type: "steps" });
+  | EventTask
+  | ExpressionTask
+  | LoadToolFromFileTask
+  | StepsTask;
 
 /**
  * Task implementation details
  */
 export type Task =
-  | (LoadToolFromFileTask & { type: "import" })
-  | (EventTask & { type: "event" })
-  | (ExpressionTask & { type: "expression" })
-  | (StepsTask & { type: "steps" })
-  | Array<
-    | (LoadToolFromFileTask & { type: "import" })
-    | (EventTask & { type: "event" })
-    | (ExpressionTask & { type: "expression" })
-    | (StepsTask & { type: "steps" })
-  >;
+  | EventTask
+  | ExpressionTask
+  | LoadToolFromFileTask
+  | StepsTask
+  | Array<EventTask | ExpressionTask | LoadToolFromFileTask | StepsTask>;
 
 export type Context = {
   /**
    * Task implementation details
    */
   task?:
-    | (LoadToolFromFileTask & { type: "import" })
-    | (EventTask & { type: "event" })
-    | (ExpressionTask & { type: "expression" })
-    | (StepsTask & { type: "steps" })
-    | Array<
-      | (LoadToolFromFileTask & { type: "import" })
-      | (EventTask & { type: "event" })
-      | (ExpressionTask & { type: "expression" })
-      | (StepsTask & { type: "steps" })
-    >
+    | EventTask
+    | ExpressionTask
+    | LoadToolFromFileTask
+    | StepsTask
+    | Array<EventTask | ExpressionTask | LoadToolFromFileTask | StepsTask>
     | null
     | undefined;
 };
@@ -80,34 +66,26 @@ export type Context = {
 /** @internal */
 export const Two$inboundSchema: z.ZodType<Two, z.ZodTypeDef, unknown> = z.union(
   [
-    LoadToolFromFileTask$inboundSchema.and(
-      z.object({ type: z.literal("import") }),
-    ),
-    EventTask$inboundSchema.and(z.object({ type: z.literal("event") })),
-    ExpressionTask$inboundSchema.and(
-      z.object({ type: z.literal("expression") }),
-    ),
-    StepsTask$inboundSchema.and(z.object({ type: z.literal("steps") })),
+    EventTask$inboundSchema,
+    ExpressionTask$inboundSchema,
+    LoadToolFromFileTask$inboundSchema,
+    StepsTask$inboundSchema,
   ],
 );
 /** @internal */
 export type Two$Outbound =
-  | (LoadToolFromFileTask$Outbound & { type: "import" })
-  | (EventTask$Outbound & { type: "event" })
-  | (ExpressionTask$Outbound & { type: "expression" })
-  | (StepsTask$Outbound & { type: "steps" });
+  | EventTask$Outbound
+  | ExpressionTask$Outbound
+  | LoadToolFromFileTask$Outbound
+  | StepsTask$Outbound;
 
 /** @internal */
 export const Two$outboundSchema: z.ZodType<Two$Outbound, z.ZodTypeDef, Two> = z
   .union([
-    LoadToolFromFileTask$outboundSchema.and(
-      z.object({ type: z.literal("import") }),
-    ),
-    EventTask$outboundSchema.and(z.object({ type: z.literal("event") })),
-    ExpressionTask$outboundSchema.and(
-      z.object({ type: z.literal("expression") }),
-    ),
-    StepsTask$outboundSchema.and(z.object({ type: z.literal("steps") })),
+    EventTask$outboundSchema,
+    ExpressionTask$outboundSchema,
+    LoadToolFromFileTask$outboundSchema,
+    StepsTask$outboundSchema,
   ]);
 
 export function twoToJSON(two: Two): string {
@@ -126,21 +104,17 @@ export function twoFromJSON(
 /** @internal */
 export const Task1$inboundSchema: z.ZodType<Task1, z.ZodTypeDef, unknown> = z
   .union([
-    LoadToolFromFileTask$inboundSchema.and(
-      z.object({ type: z.literal("import") }),
-    ),
-    EventTask$inboundSchema.and(z.object({ type: z.literal("event") })),
-    ExpressionTask$inboundSchema.and(
-      z.object({ type: z.literal("expression") }),
-    ),
-    StepsTask$inboundSchema.and(z.object({ type: z.literal("steps") })),
+    EventTask$inboundSchema,
+    ExpressionTask$inboundSchema,
+    LoadToolFromFileTask$inboundSchema,
+    StepsTask$inboundSchema,
   ]);
 /** @internal */
 export type Task1$Outbound =
-  | (LoadToolFromFileTask$Outbound & { type: "import" })
-  | (EventTask$Outbound & { type: "event" })
-  | (ExpressionTask$Outbound & { type: "expression" })
-  | (StepsTask$Outbound & { type: "steps" });
+  | EventTask$Outbound
+  | ExpressionTask$Outbound
+  | LoadToolFromFileTask$Outbound
+  | StepsTask$Outbound;
 
 /** @internal */
 export const Task1$outboundSchema: z.ZodType<
@@ -148,14 +122,10 @@ export const Task1$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Task1
 > = z.union([
-  LoadToolFromFileTask$outboundSchema.and(
-    z.object({ type: z.literal("import") }),
-  ),
-  EventTask$outboundSchema.and(z.object({ type: z.literal("event") })),
-  ExpressionTask$outboundSchema.and(
-    z.object({ type: z.literal("expression") }),
-  ),
-  StepsTask$outboundSchema.and(z.object({ type: z.literal("steps") })),
+  EventTask$outboundSchema,
+  ExpressionTask$outboundSchema,
+  LoadToolFromFileTask$outboundSchema,
+  StepsTask$outboundSchema,
 ]);
 
 export function task1ToJSON(task1: Task1): string {
@@ -175,64 +145,48 @@ export function task1FromJSON(
 export const Task$inboundSchema: z.ZodType<Task, z.ZodTypeDef, unknown> = z
   .union([
     z.union([
-      LoadToolFromFileTask$inboundSchema.and(
-        z.object({ type: z.literal("import") }),
-      ),
-      EventTask$inboundSchema.and(z.object({ type: z.literal("event") })),
-      ExpressionTask$inboundSchema.and(
-        z.object({ type: z.literal("expression") }),
-      ),
-      StepsTask$inboundSchema.and(z.object({ type: z.literal("steps") })),
+      EventTask$inboundSchema,
+      ExpressionTask$inboundSchema,
+      LoadToolFromFileTask$inboundSchema,
+      StepsTask$inboundSchema,
     ]),
     z.array(
       z.union([
-        LoadToolFromFileTask$inboundSchema.and(
-          z.object({ type: z.literal("import") }),
-        ),
-        EventTask$inboundSchema.and(z.object({ type: z.literal("event") })),
-        ExpressionTask$inboundSchema.and(
-          z.object({ type: z.literal("expression") }),
-        ),
-        StepsTask$inboundSchema.and(z.object({ type: z.literal("steps") })),
+        EventTask$inboundSchema,
+        ExpressionTask$inboundSchema,
+        LoadToolFromFileTask$inboundSchema,
+        StepsTask$inboundSchema,
       ]),
     ),
   ]);
 /** @internal */
 export type Task$Outbound =
-  | (LoadToolFromFileTask$Outbound & { type: "import" })
-  | (EventTask$Outbound & { type: "event" })
-  | (ExpressionTask$Outbound & { type: "expression" })
-  | (StepsTask$Outbound & { type: "steps" })
+  | EventTask$Outbound
+  | ExpressionTask$Outbound
+  | LoadToolFromFileTask$Outbound
+  | StepsTask$Outbound
   | Array<
-    | (LoadToolFromFileTask$Outbound & { type: "import" })
-    | (EventTask$Outbound & { type: "event" })
-    | (ExpressionTask$Outbound & { type: "expression" })
-    | (StepsTask$Outbound & { type: "steps" })
+    | EventTask$Outbound
+    | ExpressionTask$Outbound
+    | LoadToolFromFileTask$Outbound
+    | StepsTask$Outbound
   >;
 
 /** @internal */
 export const Task$outboundSchema: z.ZodType<Task$Outbound, z.ZodTypeDef, Task> =
   z.union([
     z.union([
-      LoadToolFromFileTask$outboundSchema.and(
-        z.object({ type: z.literal("import") }),
-      ),
-      EventTask$outboundSchema.and(z.object({ type: z.literal("event") })),
-      ExpressionTask$outboundSchema.and(
-        z.object({ type: z.literal("expression") }),
-      ),
-      StepsTask$outboundSchema.and(z.object({ type: z.literal("steps") })),
+      EventTask$outboundSchema,
+      ExpressionTask$outboundSchema,
+      LoadToolFromFileTask$outboundSchema,
+      StepsTask$outboundSchema,
     ]),
     z.array(
       z.union([
-        LoadToolFromFileTask$outboundSchema.and(
-          z.object({ type: z.literal("import") }),
-        ),
-        EventTask$outboundSchema.and(z.object({ type: z.literal("event") })),
-        ExpressionTask$outboundSchema.and(
-          z.object({ type: z.literal("expression") }),
-        ),
-        StepsTask$outboundSchema.and(z.object({ type: z.literal("steps") })),
+        EventTask$outboundSchema,
+        ExpressionTask$outboundSchema,
+        LoadToolFromFileTask$outboundSchema,
+        StepsTask$outboundSchema,
       ]),
     ),
   ]);
@@ -256,25 +210,17 @@ export const Context$inboundSchema: z.ZodType<Context, z.ZodTypeDef, unknown> =
     task: z.nullable(
       z.union([
         z.union([
-          LoadToolFromFileTask$inboundSchema.and(
-            z.object({ type: z.literal("import") }),
-          ),
-          EventTask$inboundSchema.and(z.object({ type: z.literal("event") })),
-          ExpressionTask$inboundSchema.and(
-            z.object({ type: z.literal("expression") }),
-          ),
-          StepsTask$inboundSchema.and(z.object({ type: z.literal("steps") })),
+          EventTask$inboundSchema,
+          ExpressionTask$inboundSchema,
+          LoadToolFromFileTask$inboundSchema,
+          StepsTask$inboundSchema,
         ]),
         z.array(
           z.union([
-            LoadToolFromFileTask$inboundSchema.and(
-              z.object({ type: z.literal("import") }),
-            ),
-            EventTask$inboundSchema.and(z.object({ type: z.literal("event") })),
-            ExpressionTask$inboundSchema.and(
-              z.object({ type: z.literal("expression") }),
-            ),
-            StepsTask$inboundSchema.and(z.object({ type: z.literal("steps") })),
+            EventTask$inboundSchema,
+            ExpressionTask$inboundSchema,
+            LoadToolFromFileTask$inboundSchema,
+            StepsTask$inboundSchema,
           ]),
         ),
       ]),
@@ -283,15 +229,15 @@ export const Context$inboundSchema: z.ZodType<Context, z.ZodTypeDef, unknown> =
 /** @internal */
 export type Context$Outbound = {
   task?:
-    | (LoadToolFromFileTask$Outbound & { type: "import" })
-    | (EventTask$Outbound & { type: "event" })
-    | (ExpressionTask$Outbound & { type: "expression" })
-    | (StepsTask$Outbound & { type: "steps" })
+    | EventTask$Outbound
+    | ExpressionTask$Outbound
+    | LoadToolFromFileTask$Outbound
+    | StepsTask$Outbound
     | Array<
-      | (LoadToolFromFileTask$Outbound & { type: "import" })
-      | (EventTask$Outbound & { type: "event" })
-      | (ExpressionTask$Outbound & { type: "expression" })
-      | (StepsTask$Outbound & { type: "steps" })
+      | EventTask$Outbound
+      | ExpressionTask$Outbound
+      | LoadToolFromFileTask$Outbound
+      | StepsTask$Outbound
     >
     | null
     | undefined;
@@ -306,25 +252,17 @@ export const Context$outboundSchema: z.ZodType<
   task: z.nullable(
     z.union([
       z.union([
-        LoadToolFromFileTask$outboundSchema.and(
-          z.object({ type: z.literal("import") }),
-        ),
-        EventTask$outboundSchema.and(z.object({ type: z.literal("event") })),
-        ExpressionTask$outboundSchema.and(
-          z.object({ type: z.literal("expression") }),
-        ),
-        StepsTask$outboundSchema.and(z.object({ type: z.literal("steps") })),
+        EventTask$outboundSchema,
+        ExpressionTask$outboundSchema,
+        LoadToolFromFileTask$outboundSchema,
+        StepsTask$outboundSchema,
       ]),
       z.array(
         z.union([
-          LoadToolFromFileTask$outboundSchema.and(
-            z.object({ type: z.literal("import") }),
-          ),
-          EventTask$outboundSchema.and(z.object({ type: z.literal("event") })),
-          ExpressionTask$outboundSchema.and(
-            z.object({ type: z.literal("expression") }),
-          ),
-          StepsTask$outboundSchema.and(z.object({ type: z.literal("steps") })),
+          EventTask$outboundSchema,
+          ExpressionTask$outboundSchema,
+          LoadToolFromFileTask$outboundSchema,
+          StepsTask$outboundSchema,
         ]),
       ),
     ]),

package/src/models/components/eventtask.ts

@@ -40,7 +40,7 @@ export type EventTask = {
   variables?: Array<Variable> | null | undefined;
   metadata?: ContextTaskMetadata | null | undefined;
   tool?: ContextToolInfo | null | undefined;
-  type?: "event" | undefined;
+  type: "event";
   version?: "v1alpha" | undefined;
   on?: EventTaskEvents | undefined;
 };
@@ -56,7 +56,7 @@ export const EventTask$inboundSchema: z.ZodType<
   variables: z.nullable(z.array(Variable$inboundSchema)).optional(),
   metadata: z.nullable(ContextTaskMetadata$inboundSchema).optional(),
   tool: z.nullable(ContextToolInfo$inboundSchema).optional(),
-  type: z.literal("event").default("event"),
+  type: z.literal("event"),
   version: z.literal("v1alpha").default("v1alpha"),
   on: EventTaskEvents$inboundSchema.optional(),
 });
@@ -83,7 +83,7 @@ export const EventTask$outboundSchema: z.ZodType<
   variables: z.nullable(z.array(Variable$outboundSchema)).optional(),
   metadata: z.nullable(ContextTaskMetadata$outboundSchema).optional(),
   tool: z.nullable(ContextToolInfo$outboundSchema).optional(),
-  type: z.literal("event").default("event" as const),
+  type: z.literal("event"),
   version: z.literal("v1alpha").default("v1alpha" as const),
   on: EventTaskEvents$outboundSchema.optional(),
 });

package/src/models/components/eventtaskevents.ts

@@ -38,11 +38,11 @@ import {
 } from "./setvalueaction.js";
 
 export type EventTaskEventsStart =
-  | (CallAction & { action: "call" })
-  | (IncrementAction & { action: "inc" })
-  | (SayAction & { action: "say" })
-  | (SetValueAction & { action: "set" })
-  | (SaveAction & { action: "save" });
+  | CallAction
+  | IncrementAction
+  | SaveAction
+  | SayAction
+  | SetValueAction;
 
 export type EventTaskEvents = {
   /**
@@ -50,11 +50,7 @@ export type EventTaskEvents = {
    */
   start?:
     | Array<
-      | (CallAction & { action: "call" })
-      | (IncrementAction & { action: "inc" })
-      | (SayAction & { action: "say" })
-      | (SetValueAction & { action: "set" })
-      | (SaveAction & { action: "save" })
+      CallAction | IncrementAction | SaveAction | SayAction | SetValueAction
     >
     | null
     | undefined;
@@ -66,19 +62,19 @@ export const EventTaskEventsStart$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  CallAction$inboundSchema.and(z.object({ action: z.literal("call") })),
-  IncrementAction$inboundSchema.and(z.object({ action: z.literal("inc") })),
-  SayAction$inboundSchema.and(z.object({ action: z.literal("say") })),
-  SetValueAction$inboundSchema.and(z.object({ action: z.literal("set") })),
-  SaveAction$inboundSchema.and(z.object({ action: z.literal("save") })),
+  CallAction$inboundSchema,
+  IncrementAction$inboundSchema,
+  SaveAction$inboundSchema,
+  SayAction$inboundSchema,
+  SetValueAction$inboundSchema,
 ]);
 /** @internal */
 export type EventTaskEventsStart$Outbound =
-  | (CallAction$Outbound & { action: "call" })
-  | (IncrementAction$Outbound & { action: "inc" })
-  | (SayAction$Outbound & { action: "say" })
-  | (SetValueAction$Outbound & { action: "set" })
-  | (SaveAction$Outbound & { action: "save" });
+  | CallAction$Outbound
+  | IncrementAction$Outbound
+  | SaveAction$Outbound
+  | SayAction$Outbound
+  | SetValueAction$Outbound;
 
 /** @internal */
 export const EventTaskEventsStart$outboundSchema: z.ZodType<
@@ -86,11 +82,11 @@ export const EventTaskEventsStart$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EventTaskEventsStart
 > = z.union([
-  CallAction$outboundSchema.and(z.object({ action: z.literal("call") })),
-  IncrementAction$outboundSchema.and(z.object({ action: z.literal("inc") })),
-  SayAction$outboundSchema.and(z.object({ action: z.literal("say") })),
-  SetValueAction$outboundSchema.and(z.object({ action: z.literal("set") })),
-  SaveAction$outboundSchema.and(z.object({ action: z.literal("save") })),
+  CallAction$outboundSchema,
+  IncrementAction$outboundSchema,
+  SaveAction$outboundSchema,
+  SayAction$outboundSchema,
+  SetValueAction$outboundSchema,
 ]);
 
 export function eventTaskEventsStartToJSON(
@@ -119,15 +115,11 @@ export const EventTaskEvents$inboundSchema: z.ZodType<
   start: z.nullable(
     z.array(
       z.union([
-        CallAction$inboundSchema.and(z.object({ action: z.literal("call") })),
-        IncrementAction$inboundSchema.and(
-          z.object({ action: z.literal("inc") }),
-        ),
-        SayAction$inboundSchema.and(z.object({ action: z.literal("say") })),
-        SetValueAction$inboundSchema.and(
-          z.object({ action: z.literal("set") }),
-        ),
-        SaveAction$inboundSchema.and(z.object({ action: z.literal("save") })),
+        CallAction$inboundSchema,
+        IncrementAction$inboundSchema,
+        SaveAction$inboundSchema,
+        SayAction$inboundSchema,
+        SetValueAction$inboundSchema,
       ]),
     ),
   ).optional(),
@@ -136,11 +128,11 @@ export const EventTaskEvents$inboundSchema: z.ZodType<
 export type EventTaskEvents$Outbound = {
   start?:
     | Array<
-      | (CallAction$Outbound & { action: "call" })
-      | (IncrementAction$Outbound & { action: "inc" })
-      | (SayAction$Outbound & { action: "say" })
-      | (SetValueAction$Outbound & { action: "set" })
-      | (SaveAction$Outbound & { action: "save" })
+      | CallAction$Outbound
+      | IncrementAction$Outbound
+      | SaveAction$Outbound
+      | SayAction$Outbound
+      | SetValueAction$Outbound
     >
     | null
     | undefined;
@@ -155,15 +147,11 @@ export const EventTaskEvents$outboundSchema: z.ZodType<
   start: z.nullable(
     z.array(
       z.union([
-        CallAction$outboundSchema.and(z.object({ action: z.literal("call") })),
-        IncrementAction$outboundSchema.and(
-          z.object({ action: z.literal("inc") }),
-        ),
-        SayAction$outboundSchema.and(z.object({ action: z.literal("say") })),
-        SetValueAction$outboundSchema.and(
-          z.object({ action: z.literal("set") }),
-        ),
-        SaveAction$outboundSchema.and(z.object({ action: z.literal("save") })),
+        CallAction$outboundSchema,
+        IncrementAction$outboundSchema,
+        SaveAction$outboundSchema,
+        SayAction$outboundSchema,
+        SetValueAction$outboundSchema,
       ]),
     ),
   ).optional(),

package/src/models/components/expressiontask.ts

@@ -56,13 +56,13 @@ import {
 } from "./variable.js";
 
 export type Expression1 =
-  | (CelExpression & { type: "cel" })
+  | CelExpression
   | (JMESPathExpression & { type: "jmespath" })
   | (JMESPathExpression & { type: "jp" });
 
 export type Expression =
   | CaseExpression
-  | (CelExpression & { type: "cel" })
+  | CelExpression
   | (JMESPathExpression & { type: "jmespath" })
   | (JMESPathExpression & { type: "jp" })
   | string;
@@ -76,12 +76,12 @@ export type ExpressionTask = {
   variables?: Array<Variable> | null | undefined;
   metadata?: ContextTaskMetadata | null | undefined;
   tool?: ContextToolInfo | null | undefined;
-  type?: "expression" | undefined;
+  type: "expression";
   version?: "v1alpha" | undefined;
   inputs?: Array<InputParameter> | undefined;
   expression?:
     | CaseExpression
-    | (CelExpression & { type: "cel" })
+    | CelExpression
     | (JMESPathExpression & { type: "jmespath" })
     | (JMESPathExpression & { type: "jp" })
     | string
@@ -100,7 +100,7 @@ export const Expression1$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
+  CelExpression$inboundSchema,
   JMESPathExpression$inboundSchema.and(
     z.object({ type: z.literal("jmespath") }),
   ),
@@ -108,7 +108,7 @@ export const Expression1$inboundSchema: z.ZodType<
 ]);
 /** @internal */
 export type Expression1$Outbound =
-  | (CelExpression$Outbound & { type: "cel" })
+  | CelExpression$Outbound
   | (JMESPathExpression$Outbound & { type: "jmespath" })
   | (JMESPathExpression$Outbound & { type: "jp" });
 
@@ -118,7 +118,7 @@ export const Expression1$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Expression1
 > = z.union([
-  CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
+  CelExpression$outboundSchema,
   JMESPathExpression$outboundSchema.and(
     z.object({ type: z.literal("jmespath") }),
   ),
@@ -146,7 +146,7 @@ export const Expression$inboundSchema: z.ZodType<
 > = z.union([
   CaseExpression$inboundSchema,
   z.union([
-    CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
+    CelExpression$inboundSchema,
     JMESPathExpression$inboundSchema.and(
       z.object({ type: z.literal("jmespath") }),
     ),
@@ -157,7 +157,7 @@ export const Expression$inboundSchema: z.ZodType<
 /** @internal */
 export type Expression$Outbound =
   | CaseExpression$Outbound
-  | (CelExpression$Outbound & { type: "cel" })
+  | CelExpression$Outbound
   | (JMESPathExpression$Outbound & { type: "jmespath" })
   | (JMESPathExpression$Outbound & { type: "jp" })
   | string;
@@ -170,7 +170,7 @@ export const Expression$outboundSchema: z.ZodType<
 > = z.union([
   CaseExpression$outboundSchema,
   z.union([
-    CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
+    CelExpression$outboundSchema,
     JMESPathExpression$outboundSchema.and(
       z.object({ type: z.literal("jmespath") }),
     ),
@@ -203,14 +203,14 @@ export const ExpressionTask$inboundSchema: z.ZodType<
   variables: z.nullable(z.array(Variable$inboundSchema)).optional(),
   metadata: z.nullable(ContextTaskMetadata$inboundSchema).optional(),
   tool: z.nullable(ContextToolInfo$inboundSchema).optional(),
-  type: z.literal("expression").default("expression"),
+  type: z.literal("expression"),
   version: z.literal("v1alpha").default("v1alpha"),
   inputs: z.array(InputParameter$inboundSchema).optional(),
   expression: z.nullable(
     z.union([
       CaseExpression$inboundSchema,
       z.union([
-        CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
+        CelExpression$inboundSchema,
         JMESPathExpression$inboundSchema.and(
           z.object({ type: z.literal("jmespath") }),
         ),
@@ -236,7 +236,7 @@ export type ExpressionTask$Outbound = {
   inputs?: Array<InputParameter$Outbound> | undefined;
   expression?:
     | CaseExpression$Outbound
-    | (CelExpression$Outbound & { type: "cel" })
+    | CelExpression$Outbound
     | (JMESPathExpression$Outbound & { type: "jmespath" })
     | (JMESPathExpression$Outbound & { type: "jp" })
     | string
@@ -257,14 +257,14 @@ export const ExpressionTask$outboundSchema: z.ZodType<
   variables: z.nullable(z.array(Variable$outboundSchema)).optional(),
   metadata: z.nullable(ContextTaskMetadata$outboundSchema).optional(),
   tool: z.nullable(ContextToolInfo$outboundSchema).optional(),
-  type: z.literal("expression").default("expression" as const),
+  type: z.literal("expression"),
   version: z.literal("v1alpha").default("v1alpha" as const),
   inputs: z.array(InputParameter$outboundSchema).optional(),
   expression: z.nullable(
     z.union([
       CaseExpression$outboundSchema,
       z.union([
-        CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
+        CelExpression$outboundSchema,
         JMESPathExpression$outboundSchema.and(
           z.object({ type: z.literal("jmespath") }),
         ),