cribl-control-plane 0.5.0-beta.3 → 0.5.0-rc.1

package/examples/example-cloud-worker-group.ts

@@ -19,14 +19,14 @@
  * Prerequisites: Replace the placeholder values for ORG_ID, CLIENT_ID, 
  * CLIENT_SECRET, and WORKSPACE_NAME with your Organization ID, Client ID and 
  * Secret, and Workspace name. To get your CLIENT_ID and CLIENT_SECRET values, 
- * follow the steps at https://docs.cribl.io/api/#criblcloud. Your Client ID 
- * and Secret are sensitive information and should be kept private.
+ * follow the steps at https://docs.cribl.io/cribl-as-code/authentication/#cloud-auth. 
+ * Your Client ID and Secret are sensitive information and should be kept private.
  * 
  * NOTE: This example is for Cribl.Cloud deployments only. It does not require 
  * .env file configuration.
  */
 
-import { ConfigGroup, ConfigGroupEstimatedIngestRate } from "../dist/esm/models";
+import { ConfigGroup, GroupCreateRequest } from "../dist/esm/models";
 import { AuthCloud } from "./auth";
 
 const ORG_ID = 'your-org-id';
@@ -46,7 +46,7 @@ const group: ConfigGroup = {
   provisioned: false,
   isFleet: false,
   isSearch: false,
-  estimatedIngestRate: ConfigGroupEstimatedIngestRate.Rate24MBPerSec, // Equivalent to 24 MB/s maximum estimated ingest rate with 9 Worker Processes
+  estimatedIngestRate: 2048, // Equivalent to 24 MB/s maximum estimated ingest rate with 9 Worker Processes
   id: WORKER_GROUP_ID,
   name: "my-aws-worker-group",
 };
@@ -68,11 +68,11 @@ async function main() {
   }
 
   // Create the Worker Group
-  await cribl.groups.create({ product: "stream", groupCreateRequest: group });
+  await cribl.groups.create({ product: "stream", groupCreateRequest: group as GroupCreateRequest });
   console.log(`✅ Worker Group created: ${group.id}`);
 
   // Scale and provision the Worker Group
-  group.estimatedIngestRate = ConfigGroupEstimatedIngestRate.Rate48MBPerSec; // Equivalent to 48 MB/s maximum estimated ingest rate with 21 Worker Processes
+  group.estimatedIngestRate = 4096; // Equivalent to 48 MB/s maximum estimated ingest rate with 21 Worker Processes
   group.provisioned = true;
   await cribl.groups.update({ product: "stream", id: group.id, configGroup: group });
   console.log(`✅ Worker Group scaled and provisioned: ${group.id}`);

package/examples/example-edge.ts

@@ -40,6 +40,7 @@ const AWS_REGION = "us-east-2"; // Replace with your S3 bucket region
 
 import {
   ConfigGroup,
+  GroupCreateRequest,
   InputSyslog,
   OutputS3,
   Pipeline,
@@ -121,7 +122,7 @@ async function main() {
   }
 
   // Create Fleet
-  await cribl.groups.create({ product: "edge", groupCreateRequest: myFleet });
+  await cribl.groups.create({ product: "edge", groupCreateRequest: myFleet as GroupCreateRequest });
   console.log(`✅ Fleet created: ${myFleet.id}`);
 
   // Create Syslog Source

package/examples/example-onprem-auth.ts

@@ -1,13 +1,13 @@
 /**
  * On-Prem Authentication Example
  * 
- * This example demonstrates the authentication process for an on-prem Cribl 
- * instance using username and password credentials.
+ * This example demonstrates how to configure authentication for an on-prem 
+ * Cribl instance using username and password credentials.
  * 
- * 1. Authenticate with your username and password to obtain a Bearer token.
- * 2. Create an SDK client that uses the Bearer token for API calls.
- * 3. Validate the connection by checking the server health status and listing 
- * all git branches.
+ * 1. Create an SDK client with username and password credentials using the 
+ * bearerAuth security scheme.
+ * 2. Automatically handle token exchange and refresh using a callback function.
+ * 3. Validate the connection by listing all git branches.
  * 
  * Prerequisites: Replace the placeholder values for ONPREM_SERVER_URL 
  * ONPREM_USERNAME, and ONPREM_PASSWORD with your server URL and credentials. 
@@ -21,33 +21,69 @@ import { CriblControlPlane } from "../dist/esm";
 
 // On-prem configuration: Replace the placeholder values
 const ONPREM_SERVER_URL: string = "http://localhost:9000";  // Replace with your server URL
-const ONPREM_USERNAME: string = "admin" // Replace with your username
-const ONPREM_PASSWORD: string = "admin" // Replace with your password
+const ONPREM_USERNAME: string = "admin"; // Replace with your username
+const ONPREM_PASSWORD: string = "admin"; // Replace with your password
 
 const BASE_URL: string = `${ONPREM_SERVER_URL}/api/v1`;
 
+// Token cache
+let _cachedToken: string | null = null;
+let _tokenExpiresAt: Date | null = null;
+
+function _getJwtExp(token: string): Date {
+  const payloadB64 = token.split(".")[1];
+  const padding = "=".repeat((4 - (payloadB64.length % 4)) % 4);
+  const payload = JSON.parse(atob(payloadB64 + padding));
+  const exp = payload.exp;
+  if (exp === undefined) {
+    throw new Error("Token missing 'exp' field");
+  }
+  return new Date(exp * 1000);
+}
+
 async function main() {
-  // Retrieve Bearer token for authentication
-  let client = new CriblControlPlane({ serverURL: BASE_URL });
-  const authResponse = await client.auth.tokens.get({
-    username: ONPREM_USERNAME,
-    password: ONPREM_PASSWORD,
-  });
-  const token = authResponse.result.token;
-  console.log(`✅ Authenticated with on-prem server. Token: ${token}`);
+  // Create client for retrieving Bearer token
+  const client = new CriblControlPlane({ serverURL: BASE_URL });
+
+  const callback = async () => {
+    // Check cache
+    const now = new Date();
+    if (
+      _cachedToken &&
+      _tokenExpiresAt &&
+      now.getTime() + 3000 < _tokenExpiresAt.getTime()
+    ) {
+      return { bearerAuth: _cachedToken };
+    }
+
+    // Retrieve Bearer token initially and refresh automatically when it expires
+    const response = await client.auth.tokens.get({
+      username: ONPREM_USERNAME,
+      password: ONPREM_PASSWORD,
+    });
+    const token = response.result.token;
+    _tokenExpiresAt = _getJwtExp(token);
+    _cachedToken = token;
+    return { bearerAuth: token };
+  };
 
   // Create authenticated SDK client
-  client = new CriblControlPlane({ serverURL: BASE_URL, security: { bearerAuth: token }});
-  console.log(`✅ Cribl SDK client created for on-prem server`);
+  const authenticatedClient = new CriblControlPlane({
+    serverURL: BASE_URL,
+    security: callback,
+  });
+  console.log(`✅ Authenticated SDK client created for on-prem server`);
 
   // Validate connection and list all git branches
-  const response = await client.versions.branches.list();
-  const branches = response.items?.map(branch => branch.id).join("\n\t");
+  const response = await authenticatedClient.versions.branches.list();
+  const branches = response.items?.map((branch: any) => branch.id).join("\n\t");
   console.log(`✅ Client works! Your list of branches:\n\t${branches}`);
 }
 
 main().catch((error) => {
-  if (error.statusCode === 429) {
+  if (error.statusCode === 401) {
+    console.log("⚠️ Authentication failed! Check your USERNAME and PASSWORD.");
+  } else if (error.statusCode === 429) {
     console.log("⚠️ Uh oh, you've reached the rate limit! Try again in a few seconds.");
   } else {
     console.error("❌ Something went wrong: ", error);

package/examples/example-stream.ts

@@ -28,6 +28,7 @@
 
 import {
   ConfigGroup,
+  GroupCreateRequest,
   InputTcpjson,
   OutputFilesystem,
   Pipeline,
@@ -107,7 +108,7 @@ async function main() {
   }
 
   // Create Worker Group
-  await cribl.groups.create({ product: "stream", groupCreateRequest: myWorkerGroup });
+  await cribl.groups.create({ product: "stream", groupCreateRequest: myWorkerGroup as GroupCreateRequest });
   console.log(`✅ Worker Group created: ${myWorkerGroup.id}`);
 
   // Create TCP JSON Source

package/examples/example-worker-group-replication.ts

@@ -22,6 +22,7 @@
  * - API Bearer token with Permissions that include creating Worker Groups.
  */
 
+import { GroupCreateRequest } from "../dist/esm/models";
 import { createCriblClient, CriblControlPlane } from './auth';
 
 /**
@@ -100,7 +101,7 @@ async function replicateWorkerGroup(client: CriblControlPlane, sourceId: string)
         id: replicaId,
         name: replicaName,
         description: `Replica of '${sourceId}'`
-      }
+      } as GroupCreateRequest
     };
 
     // Create the replica Worker Group by copying the configuration of the source Worker Group

package/examples/package-lock.json

@@ -19,7 +19,7 @@
     },
     "..": {
       "name": "cribl-control-plane",
-      "version": "0.5.0-beta.3",
+      "version": "0.5.0-rc.1",
       "dependencies": {
         "zod": "^3.25.0 || ^4.0.0"
       },

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "cribl-control-plane",
-  "version": "0.5.0-beta.3",
+  "version": "0.5.0-rc.1",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cribl-control-plane",
-  "version": "0.5.0-beta.3",
+  "version": "0.5.0-rc.1",
   "author": "Speakeasy",
   "type": "module",
   "tshy": {

package/src/funcs/pipelinesCreate.ts

@@ -33,7 +33,7 @@ import { Result } from "../types/fp.js";
  */
 export function pipelinesCreate(
   client: CriblControlPlaneCore,
-  request: models.PipelineInput,
+  request: models.Pipeline,
   options?: RequestOptions,
 ): APIPromise<
   Result<
@@ -58,7 +58,7 @@ export function pipelinesCreate(
 
 async function $do(
   client: CriblControlPlaneCore,
-  request: models.PipelineInput,
+  request: models.Pipeline,
   options?: RequestOptions,
 ): Promise<
   [
@@ -79,7 +79,7 @@ async function $do(
 > {
   const parsed = safeParse(
     request,
-    (value) => models.PipelineInput$outboundSchema.parse(value),
+    (value) => models.Pipeline$outboundSchema.parse(value),
     "Input validation failed",
   );
   if (!parsed.ok) {

package/src/lib/config.ts

@@ -61,9 +61,9 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 
 export const SDK_METADATA = {
   language: "typescript",
-  openapiDocVersion: "4.16.0-alpha.1766093766014-6100b10e",
-  sdkVersion: "0.5.0-beta.3",
+  openapiDocVersion: "4.16.0-alpha.1765998729742-5f1d1005",
+  sdkVersion: "0.5.0-rc.1",
   genVersion: "2.778.0",
   userAgent:
-    "speakeasy-sdk/typescript 0.5.0-beta.3 2.778.0 4.16.0-alpha.1766093766014-6100b10e cribl-control-plane",
+    "speakeasy-sdk/typescript 0.5.0-rc.1 2.778.0 4.16.0-alpha.1765998729742-5f1d1005 cribl-control-plane",
 } as const;

package/src/models/functionaggregatemetrics.ts

@@ -5,12 +5,103 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import {
-  FunctionConfSchemaAggregateMetrics,
-  FunctionConfSchemaAggregateMetrics$inboundSchema,
-} from "./functionconfschemaaggregatemetrics.js";
+
+/**
+ * The output metric type
+ */
+export const FunctionAggregateMetricsMetricType = {
+  Automatic: "automatic",
+  Counter: "counter",
+  Distribution: "distribution",
+  Gauge: "gauge",
+  Histogram: "histogram",
+  Summary: "summary",
+  Timer: "timer",
+} as const;
+/**
+ * The output metric type
+ */
+export type FunctionAggregateMetricsMetricType = OpenEnum<
+  typeof FunctionAggregateMetricsMetricType
+>;
+
+export type Aggregation = {
+  /**
+   * The output metric type
+   */
+  metricType?: FunctionAggregateMetricsMetricType | undefined;
+  /**
+   * Aggregate function to perform on events. Example: sum(bytes).where(action=='REJECT').as(TotalBytes)
+   */
+  agg: string;
+};
+
+export type FunctionAggregateMetricsAdd = {
+  name?: string | undefined;
+  /**
+   * JavaScript expression to compute the value (can be constant)
+   */
+  value: string;
+};
+
+export type FunctionAggregateMetricsSchema = {
+  /**
+   * Pass through the original events along with the aggregation events
+   */
+  passthrough?: boolean | undefined;
+  /**
+   * Preserve the structure of the original aggregation event's groupby fields
+   */
+  preserveGroupBys?: boolean | undefined;
+  /**
+   * Output only statistics that are sufficient for the supplied aggregations
+   */
+  sufficientStatsOnly?: boolean | undefined;
+  /**
+   * A prefix that is prepended to all of the fields output by this Aggregations Function
+   */
+  prefix?: string | undefined;
+  /**
+   * The time span of the tumbling window for aggregating events. Must be a valid time string (such as 10s).
+   */
+  timeWindow?: string | undefined;
+  /**
+   * Combination of Aggregation function and output metric type
+   */
+  aggregations?: Array<Aggregation> | undefined;
+  /**
+   * Optional: One or more dimensions to group aggregates by. Supports wildcard expressions. Wrap dimension names in quotes if using literal identifiers, such as 'service.name'. Warning: Using wildcard '*' causes all dimensions in the event to be included, which can result in high cardinality and increased memory usage. Exclude dimensions that can result in high cardinality before using wildcards. Example: !_time, !_numericValue, *
+   */
+  groupbys?: Array<string> | undefined;
+  /**
+   * The maximum number of events to include in any given aggregation event
+   */
+  flushEventLimit?: number | undefined;
+  /**
+   * The memory usage limit to impose upon aggregations. Defaults to 80% of the process memory; value configured above default limit is ignored. Accepts numerals with units like KB and MB (example: 128MB).
+   */
+  flushMemLimit?: string | undefined;
+  /**
+   * Enable to retain aggregations for cumulative aggregations when flushing out an aggregation table event. When disabled (the default), aggregations are reset to 0 on flush.
+   */
+  cumulative?: boolean | undefined;
+  /**
+   * Treat dots in dimension names as literals. This is useful for top-level dimensions that contain dots, such as 'service.name'.
+   */
+  shouldTreatDotsAsLiterals?: boolean | undefined;
+  /**
+   * Set of key-value pairs to evaluate and add/set
+   */
+  add?: Array<FunctionAggregateMetricsAdd> | undefined;
+  /**
+   * Flush aggregations when an input stream is closed. If disabled, Time Window Settings control flush behavior.
+   */
+  flushOnInputClose?: boolean | undefined;
+};
 
 export type FunctionAggregateMetrics = {
   filename: string;
@@ -26,9 +117,90 @@ export type FunctionAggregateMetrics = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaAggregateMetrics | undefined;
+  schema?: FunctionAggregateMetricsSchema | undefined;
 };
 
+/** @internal */
+export const FunctionAggregateMetricsMetricType$inboundSchema: z.ZodType<
+  FunctionAggregateMetricsMetricType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(FunctionAggregateMetricsMetricType);
+
+/** @internal */
+export const Aggregation$inboundSchema: z.ZodType<
+  Aggregation,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  metricType: FunctionAggregateMetricsMetricType$inboundSchema.default(
+    "automatic",
+  ),
+  agg: z.string(),
+});
+
+export function aggregationFromJSON(
+  jsonString: string,
+): SafeParseResult<Aggregation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Aggregation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Aggregation' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionAggregateMetricsAdd$inboundSchema: z.ZodType<
+  FunctionAggregateMetricsAdd,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  value: z.string(),
+});
+
+export function functionAggregateMetricsAddFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionAggregateMetricsAdd, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionAggregateMetricsAdd$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionAggregateMetricsAdd' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionAggregateMetricsSchema$inboundSchema: z.ZodType<
+  FunctionAggregateMetricsSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  passthrough: z.boolean().default(false),
+  preserveGroupBys: z.boolean().default(false),
+  sufficientStatsOnly: z.boolean().default(false),
+  prefix: z.string().optional(),
+  timeWindow: z.string().default("10s"),
+  aggregations: z.array(z.lazy(() => Aggregation$inboundSchema)).optional(),
+  groupbys: z.array(z.string()).optional(),
+  flushEventLimit: z.number().optional(),
+  flushMemLimit: z.string().optional(),
+  cumulative: z.boolean().default(false),
+  shouldTreatDotsAsLiterals: z.boolean().default(true),
+  add: z.array(z.lazy(() => FunctionAggregateMetricsAdd$inboundSchema))
+    .optional(),
+  flushOnInputClose: z.boolean().default(true),
+});
+
+export function functionAggregateMetricsSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionAggregateMetricsSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionAggregateMetricsSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionAggregateMetricsSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionAggregateMetrics$inboundSchema: z.ZodType<
   FunctionAggregateMetrics,
@@ -48,7 +220,7 @@ export const FunctionAggregateMetrics$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaAggregateMetrics$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionAggregateMetricsSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functionaggregation.ts

@@ -7,10 +7,77 @@ 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 {
-  FunctionConfSchemaAggregation,
-  FunctionConfSchemaAggregation$inboundSchema,
-} from "./functionconfschemaaggregation.js";
+
+export type FunctionAggregationAdd = {
+  name?: string | undefined;
+  /**
+   * JavaScript expression to compute the value (can be constant)
+   */
+  value: string;
+};
+
+export type FunctionAggregationSchema = {
+  /**
+   * Pass through the original events along with the aggregation events
+   */
+  passthrough?: boolean | undefined;
+  /**
+   * Preserve the structure of the original aggregation event's groupby fields
+   */
+  preserveGroupBys?: boolean | undefined;
+  /**
+   * Output only statistics that are sufficient for the supplied aggregations
+   */
+  sufficientStatsOnly?: boolean | undefined;
+  /**
+   * Enable to output the aggregates as metrics. When disabled, aggregates are output as events.
+   */
+  metricsMode?: boolean | undefined;
+  /**
+   * A prefix that is prepended to all of the fields output by this Aggregations Function
+   */
+  prefix?: string | undefined;
+  /**
+   * The time span of the tumbling window for aggregating events. Must be a valid time string (such as 10s).
+   */
+  timeWindow?: string | undefined;
+  /**
+   * Aggregate function to perform on events. Example: sum(bytes).where(action=='REJECT').as(TotalBytes)
+   */
+  aggregations?: Array<string> | undefined;
+  /**
+   * Optional: One or more fields to group aggregates by. Supports wildcard expressions. Warning: Using wildcard '*' causes all fields in the event to be included, which can result in high cardinality and increased memory usage. Exclude fields that can result in high cardinality before using wildcards. Example: !_time, !_numericValue, *
+   */
+  groupbys?: Array<string> | undefined;
+  /**
+   * The maximum number of events to include in any given aggregation event
+   */
+  flushEventLimit?: number | undefined;
+  /**
+   * The memory usage limit to impose upon aggregations. Defaults to 80% of the process memory; value configured above default limit is ignored. Accepts numerals with units like KB and MB (example: 128MB).
+   */
+  flushMemLimit?: string | undefined;
+  /**
+   * Enable to retain aggregations for cumulative aggregations when flushing out an aggregation table event. When disabled (the default), aggregations are reset to 0 on flush.
+   */
+  cumulative?: boolean | undefined;
+  /**
+   * Allows Cribl Search-specific aggregation configuration
+   */
+  searchAggMode?: string | undefined;
+  /**
+   * Set of key-value pairs to evaluate and add/set
+   */
+  add?: Array<FunctionAggregationAdd> | undefined;
+  /**
+   * Treat dots in dimension names as literals. This is useful for top-level dimensions that contain dots, such as 'service.name'.
+   */
+  shouldTreatDotsAsLiterals?: boolean | undefined;
+  /**
+   * Flush aggregations when an input stream is closed. If disabled, Time Window Settings control flush behavior.
+   */
+  flushOnInputClose?: boolean | undefined;
+};
 
 export type FunctionAggregation = {
   filename: string;
@@ -26,9 +93,62 @@ export type FunctionAggregation = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaAggregation | undefined;
+  schema?: FunctionAggregationSchema | undefined;
 };
 
+/** @internal */
+export const FunctionAggregationAdd$inboundSchema: z.ZodType<
+  FunctionAggregationAdd,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  value: z.string(),
+});
+
+export function functionAggregationAddFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionAggregationAdd, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionAggregationAdd$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionAggregationAdd' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionAggregationSchema$inboundSchema: z.ZodType<
+  FunctionAggregationSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  passthrough: z.boolean().default(false),
+  preserveGroupBys: z.boolean().default(false),
+  sufficientStatsOnly: z.boolean().default(false),
+  metricsMode: z.boolean().default(false),
+  prefix: z.string().optional(),
+  timeWindow: z.string().default("10s"),
+  aggregations: z.array(z.string()).optional(),
+  groupbys: z.array(z.string()).optional(),
+  flushEventLimit: z.number().optional(),
+  flushMemLimit: z.string().optional(),
+  cumulative: z.boolean().default(false),
+  searchAggMode: z.string().optional(),
+  add: z.array(z.lazy(() => FunctionAggregationAdd$inboundSchema)).optional(),
+  shouldTreatDotsAsLiterals: z.boolean().default(false),
+  flushOnInputClose: z.boolean().default(true),
+});
+
+export function functionAggregationSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionAggregationSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionAggregationSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionAggregationSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionAggregation$inboundSchema: z.ZodType<
   FunctionAggregation,
@@ -48,7 +168,7 @@ export const FunctionAggregation$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaAggregation$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionAggregationSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",