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

package/src/models/components/setvalueaction.ts

@@ -0,0 +1,508 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+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 {
+  JMESPathExpression,
+  JMESPathExpression$inboundSchema,
+  JMESPathExpression$Outbound,
+  JMESPathExpression$outboundSchema,
+} from "./jmespathexpression.js";
+
+export type SetValueActionValueFrom1 =
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" });
+
+/**
+ * Expression to compute initial value (mutually exclusive with value).
+ */
+export type SetValueActionValueFrom =
+  | CaseExpression
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" })
+  | string;
+
+export type SetValueActionIf1 =
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" });
+
+/**
+ * An expression that must evaluate to true for the action to be applied.
+ */
+export type SetValueActionIf =
+  | CaseExpression
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" })
+  | string;
+
+export type SetValueAction = {
+  /**
+   * Initial value of the variable.
+   */
+  value?: any | null | undefined;
+  /**
+   * Expression to compute initial value (mutually exclusive with value).
+   */
+  valueFrom?:
+    | CaseExpression
+    | (CelExpression & { type: "cel" })
+    | (JMESPathExpression & { type: "jmespath" })
+    | (JMESPathExpression & { type: "jp" })
+    | string
+    | null
+    | undefined;
+  /**
+   * An expression that must evaluate to true for the action to be applied.
+   */
+  if?:
+    | CaseExpression
+    | (CelExpression & { type: "cel" })
+    | (JMESPathExpression & { type: "jmespath" })
+    | (JMESPathExpression & { type: "jp" })
+    | string
+    | null
+    | undefined;
+  action?: "set" | undefined;
+  /**
+   * Destination path to mutate (e.g. output.foo).
+   */
+  name: string;
+};
+
+/** @internal */
+export const SetValueActionValueFrom1$inboundSchema: z.ZodType<
+  SetValueActionValueFrom1,
+  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 SetValueActionValueFrom1$Outbound =
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" });
+
+/** @internal */
+export const SetValueActionValueFrom1$outboundSchema: z.ZodType<
+  SetValueActionValueFrom1$Outbound,
+  z.ZodTypeDef,
+  SetValueActionValueFrom1
+> = 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 setValueActionValueFrom1ToJSON(
+  setValueActionValueFrom1: SetValueActionValueFrom1,
+): string {
+  return JSON.stringify(
+    SetValueActionValueFrom1$outboundSchema.parse(setValueActionValueFrom1),
+  );
+}
+export function setValueActionValueFrom1FromJSON(
+  jsonString: string,
+): SafeParseResult<SetValueActionValueFrom1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetValueActionValueFrom1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetValueActionValueFrom1' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetValueActionValueFrom$inboundSchema: z.ZodType<
+  SetValueActionValueFrom,
+  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 SetValueActionValueFrom$Outbound =
+  | CaseExpression$Outbound
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" })
+  | string;
+
+/** @internal */
+export const SetValueActionValueFrom$outboundSchema: z.ZodType<
+  SetValueActionValueFrom$Outbound,
+  z.ZodTypeDef,
+  SetValueActionValueFrom
+> = 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 setValueActionValueFromToJSON(
+  setValueActionValueFrom: SetValueActionValueFrom,
+): string {
+  return JSON.stringify(
+    SetValueActionValueFrom$outboundSchema.parse(setValueActionValueFrom),
+  );
+}
+export function setValueActionValueFromFromJSON(
+  jsonString: string,
+): SafeParseResult<SetValueActionValueFrom, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetValueActionValueFrom$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetValueActionValueFrom' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetValueActionIf1$inboundSchema: z.ZodType<
+  SetValueActionIf1,
+  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 SetValueActionIf1$Outbound =
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" });
+
+/** @internal */
+export const SetValueActionIf1$outboundSchema: z.ZodType<
+  SetValueActionIf1$Outbound,
+  z.ZodTypeDef,
+  SetValueActionIf1
+> = 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 setValueActionIf1ToJSON(
+  setValueActionIf1: SetValueActionIf1,
+): string {
+  return JSON.stringify(
+    SetValueActionIf1$outboundSchema.parse(setValueActionIf1),
+  );
+}
+export function setValueActionIf1FromJSON(
+  jsonString: string,
+): SafeParseResult<SetValueActionIf1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetValueActionIf1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetValueActionIf1' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetValueActionIf$inboundSchema: z.ZodType<
+  SetValueActionIf,
+  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 SetValueActionIf$Outbound =
+  | CaseExpression$Outbound
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" })
+  | string;
+
+/** @internal */
+export const SetValueActionIf$outboundSchema: z.ZodType<
+  SetValueActionIf$Outbound,
+  z.ZodTypeDef,
+  SetValueActionIf
+> = 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 setValueActionIfToJSON(
+  setValueActionIf: SetValueActionIf,
+): string {
+  return JSON.stringify(
+    SetValueActionIf$outboundSchema.parse(setValueActionIf),
+  );
+}
+export function setValueActionIfFromJSON(
+  jsonString: string,
+): SafeParseResult<SetValueActionIf, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetValueActionIf$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetValueActionIf' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetValueAction$inboundSchema: z.ZodType<
+  SetValueAction,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  value: z.nullable(z.any()).optional(),
+  value_from: 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(),
+  if: 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(),
+  action: z.literal("set").default("set"),
+  name: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "value_from": "valueFrom",
+  });
+});
+/** @internal */
+export type SetValueAction$Outbound = {
+  value?: any | null | undefined;
+  value_from?:
+    | CaseExpression$Outbound
+    | (CelExpression$Outbound & { type: "cel" })
+    | (JMESPathExpression$Outbound & { type: "jmespath" })
+    | (JMESPathExpression$Outbound & { type: "jp" })
+    | string
+    | null
+    | undefined;
+  if?:
+    | CaseExpression$Outbound
+    | (CelExpression$Outbound & { type: "cel" })
+    | (JMESPathExpression$Outbound & { type: "jmespath" })
+    | (JMESPathExpression$Outbound & { type: "jp" })
+    | string
+    | null
+    | undefined;
+  action: "set";
+  name: string;
+};
+
+/** @internal */
+export const SetValueAction$outboundSchema: z.ZodType<
+  SetValueAction$Outbound,
+  z.ZodTypeDef,
+  SetValueAction
+> = z.object({
+  value: z.nullable(z.any()).optional(),
+  valueFrom: 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(),
+  if: 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(),
+  action: z.literal("set").default("set" as const),
+  name: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    valueFrom: "value_from",
+  });
+});
+
+export function setValueActionToJSON(setValueAction: SetValueAction): string {
+  return JSON.stringify(SetValueAction$outboundSchema.parse(setValueAction));
+}
+export function setValueActionFromJSON(
+  jsonString: string,
+): SafeParseResult<SetValueAction, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetValueAction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetValueAction' from JSON`,
+  );
+}

package/src/models/components/step.ts

@@ -0,0 +1,174 @@
+/*
+ * 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 {
+  ConditionalText,
+  ConditionalText$inboundSchema,
+  ConditionalText$Outbound,
+  ConditionalText$outboundSchema,
+} from "./conditionaltext.js";
+import {
+  InputParameter,
+  InputParameter$inboundSchema,
+  InputParameter$Outbound,
+  InputParameter$outboundSchema,
+} from "./inputparameter.js";
+import {
+  NextStep,
+  NextStep$inboundSchema,
+  NextStep$Outbound,
+  NextStep$outboundSchema,
+} from "./nextstep.js";
+import {
+  StepEventActions,
+  StepEventActions$inboundSchema,
+  StepEventActions$Outbound,
+  StepEventActions$outboundSchema,
+} from "./stepeventactions.js";
+import {
+  StepTools,
+  StepTools$inboundSchema,
+  StepTools$Outbound,
+  StepTools$outboundSchema,
+} from "./steptools.js";
+
+export type Instructions = ConditionalText | string;
+
+export type Next = NextStep | string;
+
+export type Step = {
+  /**
+   * The unique identifier of the step.
+   */
+  id: string;
+  /**
+   * The goal of the step.
+   */
+  goal: string;
+  /**
+   * The instructions for the step.
+   */
+  instructions?: Array<ConditionalText | string> | undefined;
+  /**
+   * Configuration for tools available in a step.
+   */
+  tools?: StepTools | undefined;
+  /**
+   * The inputs for the step.
+   */
+  inputs?: Array<InputParameter> | undefined;
+  /**
+   * Actions to perform when events occur (enter, submit).
+   */
+  on?: StepEventActions | undefined;
+  /**
+   * The next steps to execute.
+   */
+  next?: Array<NextStep | string> | undefined;
+};
+
+/** @internal */
+export const Instructions$inboundSchema: z.ZodType<
+  Instructions,
+  z.ZodTypeDef,
+  unknown
+> = z.union([ConditionalText$inboundSchema, z.string()]);
+/** @internal */
+export type Instructions$Outbound = ConditionalText$Outbound | string;
+
+/** @internal */
+export const Instructions$outboundSchema: z.ZodType<
+  Instructions$Outbound,
+  z.ZodTypeDef,
+  Instructions
+> = z.union([ConditionalText$outboundSchema, z.string()]);
+
+export function instructionsToJSON(instructions: Instructions): string {
+  return JSON.stringify(Instructions$outboundSchema.parse(instructions));
+}
+export function instructionsFromJSON(
+  jsonString: string,
+): SafeParseResult<Instructions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Instructions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Instructions' from JSON`,
+  );
+}
+
+/** @internal */
+export const Next$inboundSchema: z.ZodType<Next, z.ZodTypeDef, unknown> = z
+  .union([NextStep$inboundSchema, z.string()]);
+/** @internal */
+export type Next$Outbound = NextStep$Outbound | string;
+
+/** @internal */
+export const Next$outboundSchema: z.ZodType<Next$Outbound, z.ZodTypeDef, Next> =
+  z.union([NextStep$outboundSchema, z.string()]);
+
+export function nextToJSON(next: Next): string {
+  return JSON.stringify(Next$outboundSchema.parse(next));
+}
+export function nextFromJSON(
+  jsonString: string,
+): SafeParseResult<Next, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Next$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Next' from JSON`,
+  );
+}
+
+/** @internal */
+export const Step$inboundSchema: z.ZodType<Step, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    goal: z.string(),
+    instructions: z.array(z.union([ConditionalText$inboundSchema, z.string()]))
+      .optional(),
+    tools: StepTools$inboundSchema.optional(),
+    inputs: z.array(InputParameter$inboundSchema).optional(),
+    on: StepEventActions$inboundSchema.optional(),
+    next: z.array(z.union([NextStep$inboundSchema, z.string()])).optional(),
+  });
+/** @internal */
+export type Step$Outbound = {
+  id: string;
+  goal: string;
+  instructions?: Array<ConditionalText$Outbound | string> | undefined;
+  tools?: StepTools$Outbound | undefined;
+  inputs?: Array<InputParameter$Outbound> | undefined;
+  on?: StepEventActions$Outbound | undefined;
+  next?: Array<NextStep$Outbound | string> | undefined;
+};
+
+/** @internal */
+export const Step$outboundSchema: z.ZodType<Step$Outbound, z.ZodTypeDef, Step> =
+  z.object({
+    id: z.string(),
+    goal: z.string(),
+    instructions: z.array(z.union([ConditionalText$outboundSchema, z.string()]))
+      .optional(),
+    tools: StepTools$outboundSchema.optional(),
+    inputs: z.array(InputParameter$outboundSchema).optional(),
+    on: StepEventActions$outboundSchema.optional(),
+    next: z.array(z.union([NextStep$outboundSchema, z.string()])).optional(),
+  });
+
+export function stepToJSON(step: Step): string {
+  return JSON.stringify(Step$outboundSchema.parse(step));
+}
+export function stepFromJSON(
+  jsonString: string,
+): SafeParseResult<Step, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Step$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Step' from JSON`,
+  );
+}