syllable-sdk 1.0.13-rc.4 → 1.0.13-rc.5

package/src/models/components/eventtaskevents.ts

@@ -0,0 +1,257 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  CallAction,
+  CallAction$inboundSchema,
+  CallAction$Outbound,
+  CallAction$outboundSchema,
+} from "./callaction.js";
+import {
+  IncrementAction,
+  IncrementAction$inboundSchema,
+  IncrementAction$Outbound,
+  IncrementAction$outboundSchema,
+} from "./incrementaction.js";
+import {
+  SaveAction,
+  SaveAction$inboundSchema,
+  SaveAction$Outbound,
+  SaveAction$outboundSchema,
+} from "./saveaction.js";
+import {
+  SayAction,
+  SayAction$inboundSchema,
+  SayAction$Outbound,
+  SayAction$outboundSchema,
+} from "./sayaction.js";
+import {
+  SetValueAction,
+  SetValueAction$inboundSchema,
+  SetValueAction$Outbound,
+  SetValueAction$outboundSchema,
+} from "./setvalueaction.js";
+
+export type EventTaskEventsStart =
+  | (CallAction & { action: "call" })
+  | (IncrementAction & { action: "inc" })
+  | (SayAction & { action: "say" })
+  | (SetValueAction & { action: "set" })
+  | (SaveAction & { action: "save" });
+
+export type EventTaskEvents = {
+  /**
+   * Actions to execute on the first input from the user.
+   */
+  start?:
+    | Array<
+      | (CallAction & { action: "call" })
+      | (IncrementAction & { action: "inc" })
+      | (SayAction & { action: "say" })
+      | (SetValueAction & { action: "set" })
+      | (SaveAction & { action: "save" })
+    >
+    | null
+    | undefined;
+};
+
+/** @internal */
+export const EventTaskEventsStart$inboundSchema: z.ZodType<
+  EventTaskEventsStart,
+  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,
+    })),
+  ),
+]);
+/** @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" });
+
+/** @internal */
+export const EventTaskEventsStart$outboundSchema: z.ZodType<
+  EventTaskEventsStart$Outbound,
+  z.ZodTypeDef,
+  EventTaskEventsStart
+> = 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,
+    })),
+  ),
+]);
+
+export function eventTaskEventsStartToJSON(
+  eventTaskEventsStart: EventTaskEventsStart,
+): string {
+  return JSON.stringify(
+    EventTaskEventsStart$outboundSchema.parse(eventTaskEventsStart),
+  );
+}
+export function eventTaskEventsStartFromJSON(
+  jsonString: string,
+): SafeParseResult<EventTaskEventsStart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventTaskEventsStart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventTaskEventsStart' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventTaskEvents$inboundSchema: z.ZodType<
+  EventTaskEvents,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  start: z.nullable(
+    z.array(
+      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,
+          })),
+        ),
+      ]),
+    ),
+  ).optional(),
+});
+/** @internal */
+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" })
+    >
+    | null
+    | undefined;
+};
+
+/** @internal */
+export const EventTaskEvents$outboundSchema: z.ZodType<
+  EventTaskEvents$Outbound,
+  z.ZodTypeDef,
+  EventTaskEvents
+> = z.object({
+  start: z.nullable(
+    z.array(
+      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,
+          })),
+        ),
+      ]),
+    ),
+  ).optional(),
+});
+
+export function eventTaskEventsToJSON(
+  eventTaskEvents: EventTaskEvents,
+): string {
+  return JSON.stringify(EventTaskEvents$outboundSchema.parse(eventTaskEvents));
+}
+export function eventTaskEventsFromJSON(
+  jsonString: string,
+): SafeParseResult<EventTaskEvents, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventTaskEvents$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventTaskEvents' from JSON`,
+  );
+}

package/src/models/components/expressiontask.ts

@@ -0,0 +1,333 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  CaseExpression,
+  CaseExpression$inboundSchema,
+  CaseExpression$Outbound,
+  CaseExpression$outboundSchema,
+} from "./caseexpression.js";
+import {
+  CelExpression,
+  CelExpression$inboundSchema,
+  CelExpression$Outbound,
+  CelExpression$outboundSchema,
+} from "./celexpression.js";
+import {
+  ContextTaskMetadata,
+  ContextTaskMetadata$inboundSchema,
+  ContextTaskMetadata$Outbound,
+  ContextTaskMetadata$outboundSchema,
+} from "./contexttaskmetadata.js";
+import {
+  ContextToolInfo,
+  ContextToolInfo$inboundSchema,
+  ContextToolInfo$Outbound,
+  ContextToolInfo$outboundSchema,
+} from "./contexttoolinfo.js";
+import {
+  ExpressionTaskEvents,
+  ExpressionTaskEvents$inboundSchema,
+  ExpressionTaskEvents$Outbound,
+  ExpressionTaskEvents$outboundSchema,
+} from "./expressiontaskevents.js";
+import {
+  InputParameter,
+  InputParameter$inboundSchema,
+  InputParameter$Outbound,
+  InputParameter$outboundSchema,
+} from "./inputparameter.js";
+import {
+  JMESPathExpression,
+  JMESPathExpression$inboundSchema,
+  JMESPathExpression$Outbound,
+  JMESPathExpression$outboundSchema,
+} from "./jmespathexpression.js";
+import {
+  Variable,
+  Variable$inboundSchema,
+  Variable$Outbound,
+  Variable$outboundSchema,
+} from "./variable.js";
+
+export type Expression1 =
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" });
+
+export type Expression =
+  | CaseExpression
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" })
+  | string;
+
+export type ExpressionTask = {
+  /**
+   * A unique identifier for the task.
+   */
+  id?: string | null | undefined;
+  config?: { [k: string]: any } | null | undefined;
+  variables?: Array<Variable> | null | undefined;
+  metadata?: ContextTaskMetadata | null | undefined;
+  tool?: ContextToolInfo | null | undefined;
+  type?: "expression" | undefined;
+  version?: "v1alpha" | undefined;
+  inputs?: Array<InputParameter> | undefined;
+  expression?:
+    | CaseExpression
+    | (CelExpression & { type: "cel" })
+    | (JMESPathExpression & { type: "jmespath" })
+    | (JMESPathExpression & { type: "jp" })
+    | string
+    | null
+    | undefined;
+  output?: any | null | undefined;
+  /**
+   * Actions to perform when events occur (enter, submit).
+   */
+  on?: ExpressionTaskEvents | undefined;
+};
+
+/** @internal */
+export const Expression1$inboundSchema: z.ZodType<
+  Expression1,
+  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,
+    })),
+  ),
+  JMESPathExpression$inboundSchema.and(
+    z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+  ),
+]);
+/** @internal */
+export type Expression1$Outbound =
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" });
+
+/** @internal */
+export const Expression1$outboundSchema: z.ZodType<
+  Expression1$Outbound,
+  z.ZodTypeDef,
+  Expression1
+> = z.union([
+  CelExpression$outboundSchema.and(
+    z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
+  ),
+  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 })),
+  ),
+]);
+
+export function expression1ToJSON(expression1: Expression1): string {
+  return JSON.stringify(Expression1$outboundSchema.parse(expression1));
+}
+export function expression1FromJSON(
+  jsonString: string,
+): SafeParseResult<Expression1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Expression1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Expression1' from JSON`,
+  );
+}
+
+/** @internal */
+export const Expression$inboundSchema: z.ZodType<
+  Expression,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  CaseExpression$inboundSchema,
+  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,
+      })),
+    ),
+    JMESPathExpression$inboundSchema.and(
+      z.object({ type: z.literal("jp") }).transform((v) => ({ type: v.type })),
+    ),
+  ]),
+  z.string(),
+]);
+/** @internal */
+export type Expression$Outbound =
+  | CaseExpression$Outbound
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" })
+  | string;
+
+/** @internal */
+export const Expression$outboundSchema: z.ZodType<
+  Expression$Outbound,
+  z.ZodTypeDef,
+  Expression
+> = z.union([
+  CaseExpression$outboundSchema,
+  z.union([
+    CelExpression$outboundSchema.and(
+      z.object({ type: z.literal("cel") }).transform((v) => ({ type: v.type })),
+    ),
+    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.string(),
+]);
+
+export function expressionToJSON(expression: Expression): string {
+  return JSON.stringify(Expression$outboundSchema.parse(expression));
+}
+export function expressionFromJSON(
+  jsonString: string,
+): SafeParseResult<Expression, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Expression$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Expression' from JSON`,
+  );
+}
+
+/** @internal */
+export const ExpressionTask$inboundSchema: z.ZodType<
+  ExpressionTask,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.nullable(z.string()).optional(),
+  config: z.nullable(z.record(z.any())).optional(),
+  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"),
+  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") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        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.string(),
+    ]),
+  ).optional(),
+  output: z.nullable(z.any()).optional(),
+  on: ExpressionTaskEvents$inboundSchema.optional(),
+});
+/** @internal */
+export type ExpressionTask$Outbound = {
+  id?: string | null | undefined;
+  config?: { [k: string]: any } | null | undefined;
+  variables?: Array<Variable$Outbound> | null | undefined;
+  metadata?: ContextTaskMetadata$Outbound | null | undefined;
+  tool?: ContextToolInfo$Outbound | null | undefined;
+  type: "expression";
+  version: "v1alpha";
+  inputs?: Array<InputParameter$Outbound> | undefined;
+  expression?:
+    | CaseExpression$Outbound
+    | (CelExpression$Outbound & { type: "cel" })
+    | (JMESPathExpression$Outbound & { type: "jmespath" })
+    | (JMESPathExpression$Outbound & { type: "jp" })
+    | string
+    | null
+    | undefined;
+  output?: any | null | undefined;
+  on?: ExpressionTaskEvents$Outbound | undefined;
+};
+
+/** @internal */
+export const ExpressionTask$outboundSchema: z.ZodType<
+  ExpressionTask$Outbound,
+  z.ZodTypeDef,
+  ExpressionTask
+> = z.object({
+  id: z.nullable(z.string()).optional(),
+  config: z.nullable(z.record(z.any())).optional(),
+  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),
+  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") }).transform((v) => ({
+            type: v.type,
+          })),
+        ),
+        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.string(),
+    ]),
+  ).optional(),
+  output: z.nullable(z.any()).optional(),
+  on: ExpressionTaskEvents$outboundSchema.optional(),
+});
+
+export function expressionTaskToJSON(expressionTask: ExpressionTask): string {
+  return JSON.stringify(ExpressionTask$outboundSchema.parse(expressionTask));
+}
+export function expressionTaskFromJSON(
+  jsonString: string,
+): SafeParseResult<ExpressionTask, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ExpressionTask$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ExpressionTask' from JSON`,
+  );
+}