chore: regenerate TypeScript SDK for unrendered template types

Author: lan17

sdks/typescript/src/generated/models/control-summary.ts

@@ -50,6 +50,10 @@ export type ControlSummary = {
    * Whether the control was created from a template
    */
   templateBacked: boolean;
+  /**
+   * Whether a template-backed control has been rendered. True for rendered templates, False for unrendered templates, None for non-template controls.
+   */
+  templateRendered?: boolean | null | undefined;
   /**
    * Agent using this control
    */
@@ -75,13 +79,15 @@ export const ControlSummary$inboundSchema: z.ZodMiniType<
     step_types: z.optional(z.nullable(z.array(types.string()))),
     tags: types.optional(z.array(types.string())),
     template_backed: z._default(types.boolean(), false),
+    template_rendered: z.optional(z.nullable(types.boolean())),
     used_by_agent: z.optional(z.nullable(AgentRef$inboundSchema)),
     used_by_agents_count: z._default(types.number(), 0),
   }),
   z.transform((v) => {
     return remap$(v, {
       "step_types": "stepTypes",
       "template_backed": "templateBacked",
+      "template_rendered": "templateRendered",
       "used_by_agent": "usedByAgent",
       "used_by_agents_count": "usedByAgentsCount",
     });

sdks/typescript/src/generated/models/control.ts

@@ -6,37 +6,61 @@ import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
+import { smartUnion } from "../types/smart-union.js";
 import {
   ControlDefinitionOutput,
   ControlDefinitionOutput$inboundSchema,
 } from "./control-definition-output.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  UnrenderedTemplateControl,
+  UnrenderedTemplateControl$inboundSchema,
+} from "./unrendered-template-control.js";
+
+export type ControlControl =
+  | ControlDefinitionOutput
+  | UnrenderedTemplateControl;
 
 /**
  * A control with identity and configuration.
  *
  * @remarks
  *
- * Note: Only fully-configured controls (with valid ControlDefinition)
- * are returned from API endpoints. Unconfigured controls are filtered out.
+ * For rendered controls (raw or template-backed), ``control`` is a
+ * ``ControlDefinition``.  For unrendered template controls, ``control``
+ * is an ``UnrenderedTemplateControl``.
  */
 export type Control = {
-  /**
-   * A control definition to evaluate agent interactions.
-   *
-   * @remarks
-   *
-   * This model contains only the logic and configuration.
-   * Identity fields (id, name) are managed by the database.
-   */
-  control: ControlDefinitionOutput;
+  control: ControlDefinitionOutput | UnrenderedTemplateControl;
   id: number;
   name: string;
 };
 
+/** @internal */
+export const ControlControl$inboundSchema: z.ZodMiniType<
+  ControlControl,
+  unknown
+> = smartUnion([
+  ControlDefinitionOutput$inboundSchema,
+  UnrenderedTemplateControl$inboundSchema,
+]);
+
+export function controlControlFromJSON(
+  jsonString: string,
+): SafeParseResult<ControlControl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ControlControl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ControlControl' from JSON`,
+  );
+}
+
 /** @internal */
 export const Control$inboundSchema: z.ZodMiniType<Control, unknown> = z.object({
-  control: ControlDefinitionOutput$inboundSchema,
+  control: smartUnion([
+    ControlDefinitionOutput$inboundSchema,
+    UnrenderedTemplateControl$inboundSchema,
+  ]),
   id: types.number(),
   name: types.string(),
 });

sdks/typescript/src/generated/models/get-control-data-response.ts

@@ -5,30 +5,59 @@
 import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { smartUnion } from "../types/smart-union.js";
 import {
   ControlDefinitionOutput,
   ControlDefinitionOutput$inboundSchema,
 } from "./control-definition-output.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  UnrenderedTemplateControl,
+  UnrenderedTemplateControl$inboundSchema,
+} from "./unrendered-template-control.js";
+
+/**
+ * Control data payload (rendered control or unrendered template)
+ */
+export type GetControlDataResponseData =
+  | ControlDefinitionOutput
+  | UnrenderedTemplateControl;
 
 export type GetControlDataResponse = {
   /**
-   * A control definition to evaluate agent interactions.
-   *
-   * @remarks
-   *
-   * This model contains only the logic and configuration.
-   * Identity fields (id, name) are managed by the database.
+   * Control data payload (rendered control or unrendered template)
    */
-  data: ControlDefinitionOutput;
+  data: ControlDefinitionOutput | UnrenderedTemplateControl;
 };
 
+/** @internal */
+export const GetControlDataResponseData$inboundSchema: z.ZodMiniType<
+  GetControlDataResponseData,
+  unknown
+> = smartUnion([
+  ControlDefinitionOutput$inboundSchema,
+  UnrenderedTemplateControl$inboundSchema,
+]);
+
+export function getControlDataResponseDataFromJSON(
+  jsonString: string,
+): SafeParseResult<GetControlDataResponseData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetControlDataResponseData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetControlDataResponseData' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetControlDataResponse$inboundSchema: z.ZodMiniType<
   GetControlDataResponse,
   unknown
 > = z.object({
-  data: ControlDefinitionOutput$inboundSchema,
+  data: smartUnion([
+    ControlDefinitionOutput$inboundSchema,
+    UnrenderedTemplateControl$inboundSchema,
+  ]),
 });
 
 export function getControlDataResponseFromJSON(

sdks/typescript/src/generated/models/get-control-response.ts

@@ -6,20 +6,32 @@ import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
+import { smartUnion } from "../types/smart-union.js";
 import {
   ControlDefinitionOutput,
   ControlDefinitionOutput$inboundSchema,
 } from "./control-definition-output.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  UnrenderedTemplateControl,
+  UnrenderedTemplateControl$inboundSchema,
+} from "./unrendered-template-control.js";
+
+/**
+ * Control configuration data. A ControlDefinition for raw/rendered controls, an UnrenderedTemplateControl for unrendered templates, or None if not yet configured.
+ */
+export type GetControlResponseData =
+  | ControlDefinitionOutput
+  | UnrenderedTemplateControl;
 
 /**
  * Response containing control details.
  */
 export type GetControlResponse = {
   /**
-   * Control configuration data (None if not yet configured)
+   * Control configuration data. A ControlDefinition for raw/rendered controls, an UnrenderedTemplateControl for unrendered templates, or None if not yet configured.
    */
-  data?: ControlDefinitionOutput | null | undefined;
+  data?: ControlDefinitionOutput | UnrenderedTemplateControl | null | undefined;
   /**
    * Control ID
    */
@@ -30,12 +42,38 @@ export type GetControlResponse = {
   name: string;
 };
 
+/** @internal */
+export const GetControlResponseData$inboundSchema: z.ZodMiniType<
+  GetControlResponseData,
+  unknown
+> = smartUnion([
+  ControlDefinitionOutput$inboundSchema,
+  UnrenderedTemplateControl$inboundSchema,
+]);
+
+export function getControlResponseDataFromJSON(
+  jsonString: string,
+): SafeParseResult<GetControlResponseData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetControlResponseData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetControlResponseData' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetControlResponse$inboundSchema: z.ZodMiniType<
   GetControlResponse,
   unknown
 > = z.object({
-  data: z.optional(z.nullable(ControlDefinitionOutput$inboundSchema)),
+  data: z.optional(
+    z.nullable(
+      smartUnion([
+        ControlDefinitionOutput$inboundSchema,
+        UnrenderedTemplateControl$inboundSchema,
+      ]),
+    ),
+  ),
   id: types.number(),
   name: types.string(),
 });

sdks/typescript/src/generated/models/index.ts

@@ -89,6 +89,7 @@ export * from "./template-definition-output.js";
 export * from "./template-parameter-definition.js";
 export * from "./template-value.js";
 export * from "./timeseries-bucket.js";
+export * from "./unrendered-template-control.js";
 export * from "./validate-control-data-request.js";
 export * from "./validate-control-data-response.js";
 export * from "./validation-error.js";

sdks/typescript/src/generated/models/unrendered-template-control.ts

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  TemplateDefinitionOutput,
+  TemplateDefinitionOutput$inboundSchema,
+} from "./template-definition-output.js";
+import {
+  TemplateValue,
+  TemplateValue$inboundSchema,
+} from "./template-value.js";
+
+/**
+ * Stored state of a template control that hasn't been rendered yet.
+ *
+ * @remarks
+ *
+ * An unrendered template has a template definition and possibly partial
+ * parameter values, but no concrete condition/action/execution fields.
+ * It is always ``enabled=False`` and excluded from evaluation.
+ */
+export type UnrenderedTemplateControl = {
+  /**
+   * Unrendered templates are always disabled
+   */
+  enabled: false;
+  /**
+   * Reusable template with typed parameters and a JSON definition template.
+   */
+  template: TemplateDefinitionOutput;
+  /**
+   * Partial or empty parameter values
+   */
+  templateValues?: { [k: string]: TemplateValue } | undefined;
+};
+
+/** @internal */
+export const UnrenderedTemplateControl$inboundSchema: z.ZodMiniType<
+  UnrenderedTemplateControl,
+  unknown
+> = z.pipe(
+  z.object({
+    enabled: z._default(types.literal(false), false),
+    template: TemplateDefinitionOutput$inboundSchema,
+    template_values: types.optional(
+      z.record(z.string(), TemplateValue$inboundSchema),
+    ),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "template_values": "templateValues",
+    });
+  }),
+);
+
+export function unrenderedTemplateControlFromJSON(
+  jsonString: string,
+): SafeParseResult<UnrenderedTemplateControl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UnrenderedTemplateControl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UnrenderedTemplateControl' from JSON`,
+  );
+}