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

package/src/models/components/conditionalvalue.ts

@@ -0,0 +1,477 @@
+/*
+ * 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 ValueFrom1 =
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" });
+
+export type If1 =
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" });
+
+/**
+ * An expression that must evaluate to true for the action to be applied.
+ */
+export type If =
+  | CaseExpression
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" })
+  | string;
+
+export type ConditionalValue = {
+  /**
+   * 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;
+};
+
+/**
+ * Expression to compute initial value (mutually exclusive with value).
+ */
+export type ValueFrom =
+  | CaseExpression
+  | (CelExpression & { type: "cel" })
+  | (JMESPathExpression & { type: "jmespath" })
+  | (JMESPathExpression & { type: "jp" })
+  | string;
+
+/** @internal */
+export const ValueFrom1$inboundSchema: z.ZodType<
+  ValueFrom1,
+  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 ValueFrom1$Outbound =
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" });
+
+/** @internal */
+export const ValueFrom1$outboundSchema: z.ZodType<
+  ValueFrom1$Outbound,
+  z.ZodTypeDef,
+  ValueFrom1
+> = 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 valueFrom1ToJSON(valueFrom1: ValueFrom1): string {
+  return JSON.stringify(ValueFrom1$outboundSchema.parse(valueFrom1));
+}
+export function valueFrom1FromJSON(
+  jsonString: string,
+): SafeParseResult<ValueFrom1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ValueFrom1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ValueFrom1' from JSON`,
+  );
+}
+
+/** @internal */
+export const If1$inboundSchema: z.ZodType<If1, 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 If1$Outbound =
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" });
+
+/** @internal */
+export const If1$outboundSchema: z.ZodType<If1$Outbound, z.ZodTypeDef, If1> = 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 if1ToJSON(if1: If1): string {
+  return JSON.stringify(If1$outboundSchema.parse(if1));
+}
+export function if1FromJSON(
+  jsonString: string,
+): SafeParseResult<If1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => If1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'If1' from JSON`,
+  );
+}
+
+/** @internal */
+export const If$inboundSchema: z.ZodType<If, z.ZodTypeDef, unknown> = z.union([
+  z.lazy(() => 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 If$Outbound =
+  | CaseExpression$Outbound
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" })
+  | string;
+
+/** @internal */
+export const If$outboundSchema: z.ZodType<If$Outbound, z.ZodTypeDef, If> = z
+  .union([
+    z.lazy(() => 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 ifToJSON(value: If): string {
+  return JSON.stringify(If$outboundSchema.parse(value));
+}
+export function ifFromJSON(
+  jsonString: string,
+): SafeParseResult<If, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => If$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'If' from JSON`,
+  );
+}
+
+/** @internal */
+export const ConditionalValue$inboundSchema: z.ZodType<
+  ConditionalValue,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  value: z.nullable(z.any()).optional(),
+  value_from: z.nullable(
+    z.union([
+      z.lazy(() => 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([
+      z.lazy(() => 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(),
+}).transform((v) => {
+  return remap$(v, {
+    "value_from": "valueFrom",
+  });
+});
+/** @internal */
+export type ConditionalValue$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;
+};
+
+/** @internal */
+export const ConditionalValue$outboundSchema: z.ZodType<
+  ConditionalValue$Outbound,
+  z.ZodTypeDef,
+  ConditionalValue
+> = z.object({
+  value: z.nullable(z.any()).optional(),
+  valueFrom: z.nullable(
+    z.union([
+      z.lazy(() => 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([
+      z.lazy(() => 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(),
+}).transform((v) => {
+  return remap$(v, {
+    valueFrom: "value_from",
+  });
+});
+
+export function conditionalValueToJSON(
+  conditionalValue: ConditionalValue,
+): string {
+  return JSON.stringify(
+    ConditionalValue$outboundSchema.parse(conditionalValue),
+  );
+}
+export function conditionalValueFromJSON(
+  jsonString: string,
+): SafeParseResult<ConditionalValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConditionalValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConditionalValue' from JSON`,
+  );
+}
+
+/** @internal */
+export const ValueFrom$inboundSchema: z.ZodType<
+  ValueFrom,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => 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 ValueFrom$Outbound =
+  | CaseExpression$Outbound
+  | (CelExpression$Outbound & { type: "cel" })
+  | (JMESPathExpression$Outbound & { type: "jmespath" })
+  | (JMESPathExpression$Outbound & { type: "jp" })
+  | string;
+
+/** @internal */
+export const ValueFrom$outboundSchema: z.ZodType<
+  ValueFrom$Outbound,
+  z.ZodTypeDef,
+  ValueFrom
+> = z.union([
+  z.lazy(() => 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 valueFromToJSON(valueFrom: ValueFrom): string {
+  return JSON.stringify(ValueFrom$outboundSchema.parse(valueFrom));
+}
+export function valueFromFromJSON(
+  jsonString: string,
+): SafeParseResult<ValueFrom, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ValueFrom$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ValueFrom' from JSON`,
+  );
+}