syllable-sdk 1.0.13-rc.5 → 1.0.13

package/src/models/components/expressiontaskevents.ts

@@ -86,31 +86,11 @@ export type ExpressionTaskEvents = {
 /** @internal */
 export const Start$inboundSchema: z.ZodType<Start, z.ZodTypeDef, unknown> = z
   .union([
-    CallAction$inboundSchema.and(
-      z.object({ action: z.literal("call") }).transform((v) => ({
-        action: v.action,
-      })),
-    ),
-    IncrementAction$inboundSchema.and(
-      z.object({ action: z.literal("inc") }).transform((v) => ({
-        action: v.action,
-      })),
-    ),
-    SayAction$inboundSchema.and(
-      z.object({ action: z.literal("say") }).transform((v) => ({
-        action: v.action,
-      })),
-    ),
-    SetValueAction$inboundSchema.and(
-      z.object({ action: z.literal("set") }).transform((v) => ({
-        action: v.action,
-      })),
-    ),
-    SaveAction$inboundSchema.and(
-      z.object({ action: z.literal("save") }).transform((v) => ({
-        action: v.action,
-      })),
-    ),
+    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") })),
   ]);
 /** @internal */
 export type Start$Outbound =
@@ -126,31 +106,11 @@ export const Start$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Start
 > = z.union([
-  CallAction$outboundSchema.and(
-    z.object({ action: z.literal("call") }).transform((v) => ({
-      action: v.action,
-    })),
-  ),
-  IncrementAction$outboundSchema.and(
-    z.object({ action: z.literal("inc") }).transform((v) => ({
-      action: v.action,
-    })),
-  ),
-  SayAction$outboundSchema.and(
-    z.object({ action: z.literal("say") }).transform((v) => ({
-      action: v.action,
-    })),
-  ),
-  SetValueAction$outboundSchema.and(
-    z.object({ action: z.literal("set") }).transform((v) => ({
-      action: v.action,
-    })),
-  ),
-  SaveAction$outboundSchema.and(
-    z.object({ action: z.literal("save") }).transform((v) => ({
-      action: v.action,
-    })),
-  ),
+  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") })),
 ]);
 
 export function startToJSON(start: Start): string {
@@ -169,31 +129,11 @@ export function startFromJSON(
 /** @internal */
 export const Submit$inboundSchema: z.ZodType<Submit, z.ZodTypeDef, unknown> = z
   .union([
-    CallAction$inboundSchema.and(
-      z.object({ action: z.literal("call") }).transform((v) => ({
-        action: v.action,
-      })),
-    ),
-    IncrementAction$inboundSchema.and(
-      z.object({ action: z.literal("inc") }).transform((v) => ({
-        action: v.action,
-      })),
-    ),
-    SayAction$inboundSchema.and(
-      z.object({ action: z.literal("say") }).transform((v) => ({
-        action: v.action,
-      })),
-    ),
-    SetValueAction$inboundSchema.and(
-      z.object({ action: z.literal("set") }).transform((v) => ({
-        action: v.action,
-      })),
-    ),
-    SaveAction$inboundSchema.and(
-      z.object({ action: z.literal("save") }).transform((v) => ({
-        action: v.action,
-      })),
-    ),
+    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") })),
   ]);
 /** @internal */
 export type Submit$Outbound =
@@ -209,31 +149,11 @@ export const Submit$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Submit
 > = z.union([
-  CallAction$outboundSchema.and(
-    z.object({ action: z.literal("call") }).transform((v) => ({
-      action: v.action,
-    })),
-  ),
-  IncrementAction$outboundSchema.and(
-    z.object({ action: z.literal("inc") }).transform((v) => ({
-      action: v.action,
-    })),
-  ),
-  SayAction$outboundSchema.and(
-    z.object({ action: z.literal("say") }).transform((v) => ({
-      action: v.action,
-    })),
-  ),
-  SetValueAction$outboundSchema.and(
-    z.object({ action: z.literal("set") }).transform((v) => ({
-      action: v.action,
-    })),
-  ),
-  SaveAction$outboundSchema.and(
-    z.object({ action: z.literal("save") }).transform((v) => ({
-      action: v.action,
-    })),
-  ),
+  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") })),
 ]);
 
 export function submitToJSON(submit: Submit): string {
@@ -258,62 +178,30 @@ export const ExpressionTaskEvents$inboundSchema: z.ZodType<
   start: z.nullable(
     z.array(
       z.union([
-        CallAction$inboundSchema.and(
-          z.object({ action: z.literal("call") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
+        CallAction$inboundSchema.and(z.object({ action: z.literal("call") })),
         IncrementAction$inboundSchema.and(
-          z.object({ action: z.literal("inc") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
-        SayAction$inboundSchema.and(
-          z.object({ action: z.literal("say") }).transform((v) => ({
-            action: v.action,
-          })),
+          z.object({ action: z.literal("inc") }),
         ),
+        SayAction$inboundSchema.and(z.object({ action: z.literal("say") })),
         SetValueAction$inboundSchema.and(
-          z.object({ action: z.literal("set") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
-        SaveAction$inboundSchema.and(
-          z.object({ action: z.literal("save") }).transform((v) => ({
-            action: v.action,
-          })),
+          z.object({ action: z.literal("set") }),
         ),
+        SaveAction$inboundSchema.and(z.object({ action: z.literal("save") })),
       ]),
     ),
   ).optional(),
   submit: z.nullable(
     z.array(
       z.union([
-        CallAction$inboundSchema.and(
-          z.object({ action: z.literal("call") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
+        CallAction$inboundSchema.and(z.object({ action: z.literal("call") })),
         IncrementAction$inboundSchema.and(
-          z.object({ action: z.literal("inc") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
-        SayAction$inboundSchema.and(
-          z.object({ action: z.literal("say") }).transform((v) => ({
-            action: v.action,
-          })),
+          z.object({ action: z.literal("inc") }),
         ),
+        SayAction$inboundSchema.and(z.object({ action: z.literal("say") })),
         SetValueAction$inboundSchema.and(
-          z.object({ action: z.literal("set") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
-        SaveAction$inboundSchema.and(
-          z.object({ action: z.literal("save") }).transform((v) => ({
-            action: v.action,
-          })),
+          z.object({ action: z.literal("set") }),
         ),
+        SaveAction$inboundSchema.and(z.object({ action: z.literal("save") })),
       ]),
     ),
   ).optional(),
@@ -351,62 +239,30 @@ export const ExpressionTaskEvents$outboundSchema: z.ZodType<
   start: z.nullable(
     z.array(
       z.union([
-        CallAction$outboundSchema.and(
-          z.object({ action: z.literal("call") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
+        CallAction$outboundSchema.and(z.object({ action: z.literal("call") })),
         IncrementAction$outboundSchema.and(
-          z.object({ action: z.literal("inc") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
-        SayAction$outboundSchema.and(
-          z.object({ action: z.literal("say") }).transform((v) => ({
-            action: v.action,
-          })),
+          z.object({ action: z.literal("inc") }),
         ),
+        SayAction$outboundSchema.and(z.object({ action: z.literal("say") })),
         SetValueAction$outboundSchema.and(
-          z.object({ action: z.literal("set") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
-        SaveAction$outboundSchema.and(
-          z.object({ action: z.literal("save") }).transform((v) => ({
-            action: v.action,
-          })),
+          z.object({ action: z.literal("set") }),
         ),
+        SaveAction$outboundSchema.and(z.object({ action: z.literal("save") })),
       ]),
     ),
   ).optional(),
   submit: z.nullable(
     z.array(
       z.union([
-        CallAction$outboundSchema.and(
-          z.object({ action: z.literal("call") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
+        CallAction$outboundSchema.and(z.object({ action: z.literal("call") })),
         IncrementAction$outboundSchema.and(
-          z.object({ action: z.literal("inc") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
-        SayAction$outboundSchema.and(
-          z.object({ action: z.literal("say") }).transform((v) => ({
-            action: v.action,
-          })),
+          z.object({ action: z.literal("inc") }),
         ),
+        SayAction$outboundSchema.and(z.object({ action: z.literal("say") })),
         SetValueAction$outboundSchema.and(
-          z.object({ action: z.literal("set") }).transform((v) => ({
-            action: v.action,
-          })),
-        ),
-        SaveAction$outboundSchema.and(
-          z.object({ action: z.literal("save") }).transform((v) => ({
-            action: v.action,
-          })),
+          z.object({ action: z.literal("set") }),
         ),
+        SaveAction$outboundSchema.and(z.object({ action: z.literal("save") })),
       ]),
     ),
   ).optional(),

package/src/models/components/incrementaction.ts

@@ -69,17 +69,11 @@ export const IncrementActionIf1$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  CelExpression$inboundSchema.and(
-    z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-  ),
-  JMESPathExpression$inboundSchema.and(
-    z.object({ type: z.literal("jmespath") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
+  CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
   JMESPathExpression$inboundSchema.and(
-    z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+    z.object({ type: z.literal("jmespath") }),
   ),
+  JMESPathExpression$inboundSchema.and(z.object({ type: z.literal("jp") })),
 ]);
 /** @internal */
 export type IncrementActionIf1$Outbound =
@@ -93,17 +87,11 @@ export const IncrementActionIf1$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   IncrementActionIf1
 > = z.union([
-  CelExpression$outboundSchema.and(
-    z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-  ),
+  CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
   JMESPathExpression$outboundSchema.and(
-    z.object({ type: z.literal("jmespath") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  JMESPathExpression$outboundSchema.and(
-    z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+    z.object({ type: z.literal("jmespath") }),
   ),
+  JMESPathExpression$outboundSchema.and(z.object({ type: z.literal("jp") })),
 ]);
 
 export function incrementActionIf1ToJSON(
@@ -131,17 +119,11 @@ export const IncrementActionIf$inboundSchema: z.ZodType<
 > = z.union([
   CaseExpression$inboundSchema,
   z.union([
-    CelExpression$inboundSchema.and(
-      z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-    ),
+    CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
     JMESPathExpression$inboundSchema.and(
-      z.object({ type: z.literal("jmespath") }).transform((v) => ({
-        type: v.type,
-      })),
-    ),
-    JMESPathExpression$inboundSchema.and(
-      z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+      z.object({ type: z.literal("jmespath") }),
     ),
+    JMESPathExpression$inboundSchema.and(z.object({ type: z.literal("jp") })),
   ]),
   z.string(),
 ]);
@@ -161,17 +143,11 @@ export const IncrementActionIf$outboundSchema: z.ZodType<
 > = z.union([
   CaseExpression$outboundSchema,
   z.union([
-    CelExpression$outboundSchema.and(
-      z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-    ),
+    CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
     JMESPathExpression$outboundSchema.and(
-      z.object({ type: z.literal("jmespath") }).transform((v) => ({
-        type: v.type,
-      })),
-    ),
-    JMESPathExpression$outboundSchema.and(
-      z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+      z.object({ type: z.literal("jmespath") }),
     ),
+    JMESPathExpression$outboundSchema.and(z.object({ type: z.literal("jp") })),
   ]),
   z.string(),
 ]);
@@ -203,20 +179,12 @@ export const IncrementAction$inboundSchema: z.ZodType<
     z.union([
       CaseExpression$inboundSchema,
       z.union([
-        CelExpression$inboundSchema.and(
-          z.object({ type: z.literal("cel") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
+        CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
         JMESPathExpression$inboundSchema.and(
-          z.object({ type: z.literal("jmespath") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jmespath") }),
         ),
         JMESPathExpression$inboundSchema.and(
-          z.object({ type: z.literal("jp") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jp") }),
         ),
       ]),
       z.string(),
@@ -251,20 +219,12 @@ export const IncrementAction$outboundSchema: z.ZodType<
     z.union([
       CaseExpression$outboundSchema,
       z.union([
-        CelExpression$outboundSchema.and(
-          z.object({ type: z.literal("cel") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
+        CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
         JMESPathExpression$outboundSchema.and(
-          z.object({ type: z.literal("jmespath") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jmespath") }),
         ),
         JMESPathExpression$outboundSchema.and(
-          z.object({ type: z.literal("jp") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jp") }),
         ),
       ]),
       z.string(),

package/src/models/components/nextstep.ts

@@ -71,17 +71,11 @@ export const NextStepIf1$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  CelExpression$inboundSchema.and(
-    z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-  ),
-  JMESPathExpression$inboundSchema.and(
-    z.object({ type: z.literal("jmespath") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
+  CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
   JMESPathExpression$inboundSchema.and(
-    z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+    z.object({ type: z.literal("jmespath") }),
   ),
+  JMESPathExpression$inboundSchema.and(z.object({ type: z.literal("jp") })),
 ]);
 /** @internal */
 export type NextStepIf1$Outbound =
@@ -95,17 +89,11 @@ export const NextStepIf1$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   NextStepIf1
 > = z.union([
-  CelExpression$outboundSchema.and(
-    z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-  ),
+  CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
   JMESPathExpression$outboundSchema.and(
-    z.object({ type: z.literal("jmespath") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  JMESPathExpression$outboundSchema.and(
-    z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+    z.object({ type: z.literal("jmespath") }),
   ),
+  JMESPathExpression$outboundSchema.and(z.object({ type: z.literal("jp") })),
 ]);
 
 export function nextStepIf1ToJSON(nextStepIf1: NextStepIf1): string {
@@ -129,17 +117,11 @@ export const NextStepIf$inboundSchema: z.ZodType<
 > = z.union([
   CaseExpression$inboundSchema,
   z.union([
-    CelExpression$inboundSchema.and(
-      z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-    ),
+    CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
     JMESPathExpression$inboundSchema.and(
-      z.object({ type: z.literal("jmespath") }).transform((v) => ({
-        type: v.type,
-      })),
-    ),
-    JMESPathExpression$inboundSchema.and(
-      z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+      z.object({ type: z.literal("jmespath") }),
     ),
+    JMESPathExpression$inboundSchema.and(z.object({ type: z.literal("jp") })),
   ]),
   z.string(),
 ]);
@@ -159,17 +141,11 @@ export const NextStepIf$outboundSchema: z.ZodType<
 > = z.union([
   CaseExpression$outboundSchema,
   z.union([
-    CelExpression$outboundSchema.and(
-      z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-    ),
+    CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
     JMESPathExpression$outboundSchema.and(
-      z.object({ type: z.literal("jmespath") }).transform((v) => ({
-        type: v.type,
-      })),
-    ),
-    JMESPathExpression$outboundSchema.and(
-      z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+      z.object({ type: z.literal("jmespath") }),
     ),
+    JMESPathExpression$outboundSchema.and(z.object({ type: z.literal("jp") })),
   ]),
   z.string(),
 ]);
@@ -197,20 +173,12 @@ export const NextStep$inboundSchema: z.ZodType<
     z.union([
       CaseExpression$inboundSchema,
       z.union([
-        CelExpression$inboundSchema.and(
-          z.object({ type: z.literal("cel") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
+        CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
         JMESPathExpression$inboundSchema.and(
-          z.object({ type: z.literal("jmespath") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jmespath") }),
         ),
         JMESPathExpression$inboundSchema.and(
-          z.object({ type: z.literal("jp") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jp") }),
         ),
       ]),
       z.string(),
@@ -243,20 +211,12 @@ export const NextStep$outboundSchema: z.ZodType<
     z.union([
       CaseExpression$outboundSchema,
       z.union([
-        CelExpression$outboundSchema.and(
-          z.object({ type: z.literal("cel") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
+        CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
         JMESPathExpression$outboundSchema.and(
-          z.object({ type: z.literal("jmespath") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jmespath") }),
         ),
         JMESPathExpression$outboundSchema.and(
-          z.object({ type: z.literal("jp") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jp") }),
         ),
       ]),
       z.string(),

package/src/models/components/saveaction.ts

@@ -69,17 +69,11 @@ export const SaveActionIf1$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  CelExpression$inboundSchema.and(
-    z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-  ),
-  JMESPathExpression$inboundSchema.and(
-    z.object({ type: z.literal("jmespath") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
+  CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
   JMESPathExpression$inboundSchema.and(
-    z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+    z.object({ type: z.literal("jmespath") }),
   ),
+  JMESPathExpression$inboundSchema.and(z.object({ type: z.literal("jp") })),
 ]);
 /** @internal */
 export type SaveActionIf1$Outbound =
@@ -93,17 +87,11 @@ export const SaveActionIf1$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   SaveActionIf1
 > = z.union([
-  CelExpression$outboundSchema.and(
-    z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-  ),
+  CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
   JMESPathExpression$outboundSchema.and(
-    z.object({ type: z.literal("jmespath") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
-  JMESPathExpression$outboundSchema.and(
-    z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+    z.object({ type: z.literal("jmespath") }),
   ),
+  JMESPathExpression$outboundSchema.and(z.object({ type: z.literal("jp") })),
 ]);
 
 export function saveActionIf1ToJSON(saveActionIf1: SaveActionIf1): string {
@@ -127,17 +115,11 @@ export const SaveActionIf$inboundSchema: z.ZodType<
 > = z.union([
   CaseExpression$inboundSchema,
   z.union([
-    CelExpression$inboundSchema.and(
-      z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-    ),
+    CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
     JMESPathExpression$inboundSchema.and(
-      z.object({ type: z.literal("jmespath") }).transform((v) => ({
-        type: v.type,
-      })),
-    ),
-    JMESPathExpression$inboundSchema.and(
-      z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+      z.object({ type: z.literal("jmespath") }),
     ),
+    JMESPathExpression$inboundSchema.and(z.object({ type: z.literal("jp") })),
   ]),
   z.string(),
 ]);
@@ -157,17 +139,11 @@ export const SaveActionIf$outboundSchema: z.ZodType<
 > = z.union([
   CaseExpression$outboundSchema,
   z.union([
-    CelExpression$outboundSchema.and(
-      z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
-    ),
+    CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
     JMESPathExpression$outboundSchema.and(
-      z.object({ type: z.literal("jmespath") }).transform((v) => ({
-        type: v.type,
-      })),
-    ),
-    JMESPathExpression$outboundSchema.and(
-      z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+      z.object({ type: z.literal("jmespath") }),
     ),
+    JMESPathExpression$outboundSchema.and(z.object({ type: z.literal("jp") })),
   ]),
   z.string(),
 ]);
@@ -195,20 +171,12 @@ export const SaveAction$inboundSchema: z.ZodType<
     z.union([
       CaseExpression$inboundSchema,
       z.union([
-        CelExpression$inboundSchema.and(
-          z.object({ type: z.literal("cel") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
+        CelExpression$inboundSchema.and(z.object({ type: z.literal("cel") })),
         JMESPathExpression$inboundSchema.and(
-          z.object({ type: z.literal("jmespath") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jmespath") }),
         ),
         JMESPathExpression$inboundSchema.and(
-          z.object({ type: z.literal("jp") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jp") }),
         ),
       ]),
       z.string(),
@@ -243,20 +211,12 @@ export const SaveAction$outboundSchema: z.ZodType<
     z.union([
       CaseExpression$outboundSchema,
       z.union([
-        CelExpression$outboundSchema.and(
-          z.object({ type: z.literal("cel") }).transform((v) => ({
-            type: v.type,
-          })),
-        ),
+        CelExpression$outboundSchema.and(z.object({ type: z.literal("cel") })),
         JMESPathExpression$outboundSchema.and(
-          z.object({ type: z.literal("jmespath") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jmespath") }),
         ),
         JMESPathExpression$outboundSchema.and(
-          z.object({ type: z.literal("jp") }).transform((v) => ({
-            type: v.type,
-          })),
+          z.object({ type: z.literal("jp") }),
         ),
       ]),
       z.string(),