@continuous-labs/sdk 0.0.6 → 0.0.8

package/src/funcs/worlds-cancel-world-build.ts

@@ -167,7 +167,7 @@ async function $do(
     | SDKValidationError
   >(
     M.json(200, models.World$inboundSchema),
-    M.jsonErr([400, 401, 403, 404, 409], errors.ErrorT$inboundSchema, {
+    M.jsonErr([401, 403, 404], errors.ErrorT$inboundSchema, {
       ctype: "application/problem+json",
     }),
     M.jsonErr([500, 503], errors.ErrorT$inboundSchema, {

package/src/funcs/worlds-delete-world.ts

@@ -165,7 +165,7 @@ async function $do(
     | SDKValidationError
   >(
     M.nil(204, z.void()),
-    M.jsonErr([400, 401, 403, 404, 409], errors.ErrorT$inboundSchema, {
+    M.jsonErr([401, 403, 404], errors.ErrorT$inboundSchema, {
       ctype: "application/problem+json",
     }),
     M.jsonErr([500, 503], errors.ErrorT$inboundSchema, {

package/src/funcs/worlds-get-world.ts

@@ -166,7 +166,7 @@ async function $do(
     | SDKValidationError
   >(
     M.json(200, models.World$inboundSchema),
-    M.jsonErr([400, 401, 403, 404], errors.ErrorT$inboundSchema, {
+    M.jsonErr([401, 403, 404], errors.ErrorT$inboundSchema, {
       ctype: "application/problem+json",
     }),
     M.jsonErr([500, 503], errors.ErrorT$inboundSchema, {

package/src/funcs/worlds-list-worlds.ts

@@ -167,7 +167,7 @@ async function $do(
     | SDKValidationError
   >(
     M.json(200, models.ListWorldsResponse$inboundSchema),
-    M.jsonErr([400, 401, 403, 404, 422], errors.ErrorT$inboundSchema, {
+    M.jsonErr([400, 401, 422], errors.ErrorT$inboundSchema, {
       ctype: "application/problem+json",
     }),
     M.jsonErr([500, 503], errors.ErrorT$inboundSchema, {

package/src/funcs/worlds-start-world.ts

@@ -166,7 +166,7 @@ async function $do(
     | SDKValidationError
   >(
     M.json(200, models.World$inboundSchema),
-    M.jsonErr([400, 401, 403, 404, 409, 429], errors.ErrorT$inboundSchema, {
+    M.jsonErr([401, 403, 404, 409, 429], errors.ErrorT$inboundSchema, {
       ctype: "application/problem+json",
     }),
     M.jsonErr([500, 503], errors.ErrorT$inboundSchema, {

package/src/funcs/worlds-stop-world.ts

@@ -166,7 +166,7 @@ async function $do(
     | SDKValidationError
   >(
     M.json(200, models.World$inboundSchema),
-    M.jsonErr([400, 401, 403, 404, 409], errors.ErrorT$inboundSchema, {
+    M.jsonErr([401, 403, 404, 409], errors.ErrorT$inboundSchema, {
       ctype: "application/problem+json",
     }),
     M.jsonErr([500, 503], errors.ErrorT$inboundSchema, {

package/src/lib/config.ts

@@ -61,7 +61,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "v1",
-  sdkVersion: "0.0.6",
+  sdkVersion: "0.0.8",
   genVersion: "2.935.1",
-  userAgent: "speakeasy-sdk/typescript 0.0.6 2.935.1 v1 @continuous-labs/sdk",
+  userAgent: "speakeasy-sdk/typescript 0.0.8 2.935.1 v1 @continuous-labs/sdk",
 } as const;

package/src/models/build-simulator-request.ts

@@ -9,14 +9,16 @@ import { ClosedEnum } from "../types/enums.js";
 /**
  * Model provider that builds the Simulator. Defaults to claude.
  */
-export const Builder = {
+export const BuildSimulatorRequestBuilder = {
   Openai: "openai",
   Claude: "claude",
 } as const;
 /**
  * Model provider that builds the Simulator. Defaults to claude.
  */
-export type Builder = ClosedEnum<typeof Builder>;
+export type BuildSimulatorRequestBuilder = ClosedEnum<
+  typeof BuildSimulatorRequestBuilder
+>;
 
 /**
  * Source specification format. Omission detects the format.
@@ -34,7 +36,7 @@ export type BuildSimulatorRequest = {
   /**
    * Model provider that builds the Simulator. Defaults to claude.
    */
-  builder?: Builder | undefined;
+  builder?: BuildSimulatorRequestBuilder | undefined;
   /**
    * Regular expressions (RE2 syntax) that select the operations to implement. Each is matched against the OpenAPI operationId or the WSDL operation name; an operation is kept when any expression matches, and an OpenAPI operation without an operationId is dropped. At most 64 expressions of at most 1,024 characters each. Omit or send an empty list to keep every operation. Not allowed for an incremental build.
    */
@@ -58,9 +60,9 @@ export type BuildSimulatorRequest = {
 };
 
 /** @internal */
-export const Builder$outboundSchema: z.ZodMiniEnum<typeof Builder> = z.enum(
-  Builder,
-);
+export const BuildSimulatorRequestBuilder$outboundSchema: z.ZodMiniEnum<
+  typeof BuildSimulatorRequestBuilder
+> = z.enum(BuildSimulatorRequestBuilder);
 
 /** @internal */
 export const SpecKind$outboundSchema: z.ZodMiniEnum<typeof SpecKind> = z.enum(
@@ -83,7 +85,7 @@ export const BuildSimulatorRequest$outboundSchema: z.ZodMiniType<
   BuildSimulatorRequest
 > = z.pipe(
   z.object({
-    builder: z._default(Builder$outboundSchema, "claude"),
+    builder: z._default(BuildSimulatorRequestBuilder$outboundSchema, "claude"),
     filter: z.optional(z.array(z.string())),
     instructions: z.optional(z.string()),
     name: z.optional(z.string()),

package/src/models/build-world-request.ts

@@ -6,7 +6,7 @@ import * as z from "zod/v4-mini";
 
 export type BuildWorldRequest = {
   /**
-   * Instructions for the builder. At most 16,384 characters and 65,536 UTF-8 bytes; must not be blank or contain U+0000.
+   * Describe the initial data, scenario, and relationships. Populated Worlds support up to 8 selected Simulators and 1,000 starting records in total. Named record types replace their default data. At most 16,384 characters and 65,536 UTF-8 bytes. U+0000 is not permitted.
    */
   instructions?: string | undefined;
   /**

package/src/models/index.ts

@@ -12,11 +12,16 @@ export * from "./list-simulations-response.js";
 export * from "./list-simulators-response.js";
 export * from "./list-worlds-response.js";
 export * from "./mint-simulation-token-request.js";
-export * from "./resource-error.js";
 export * from "./security.js";
 export * from "./simulation-token.js";
 export * from "./simulation.js";
+export * from "./simulator-build-progress.js";
+export * from "./simulator-error.js";
 export * from "./simulator.js";
 export * from "./step.js";
+export * from "./world-build.js";
+export * from "./world-data-summary.js";
+export * from "./world-error.js";
+export * from "./world-record-count.js";
 export * from "./world-simulation.js";
 export * from "./world.js";

package/src/models/operations/build-simulator.ts

@@ -3,7 +3,11 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
 import { blobLikeSchema } from "../../types/blobs.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
 import * as models from "../index.js";
 
 export type Spec = {
@@ -19,6 +23,11 @@ export type BuildSimulatorRequest = {
   spec?: Spec | Blob | undefined;
 };
 
+export type BuildSimulatorResponse = {
+  headers: { [k: string]: Array<string> };
+  result: models.Simulator;
+};
+
 /** @internal */
 export type Spec$Outbound = {
   fileName: string;
@@ -66,3 +75,30 @@ export function buildSimulatorRequestToJSON(
     BuildSimulatorRequest$outboundSchema.parse(buildSimulatorRequest),
   );
 }
+
+/** @internal */
+export const BuildSimulatorResponse$inboundSchema: z.ZodMiniType<
+  BuildSimulatorResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    Headers: z._default(z.record(z.string(), z.array(z.string())), {}),
+    Result: models.Simulator$inboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "Headers": "headers",
+      "Result": "result",
+    });
+  }),
+);
+
+export function buildSimulatorResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<BuildSimulatorResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BuildSimulatorResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BuildSimulatorResponse' from JSON`,
+  );
+}

package/src/models/simulator-build-progress.ts

@@ -0,0 +1,136 @@
+/*
+ * 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 * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+/**
+ * The coding-loop provider.
+ */
+export const SimulatorBuildProgressBuilder = {
+  Claude: "claude",
+  Openai: "openai",
+} as const;
+/**
+ * The coding-loop provider.
+ */
+export type SimulatorBuildProgressBuilder = OpenEnum<
+  typeof SimulatorBuildProgressBuilder
+>;
+
+/**
+ * Outcome of the most recent submit attempt, or null.
+ */
+export const LastSubmission = {
+  Accepted: "accepted",
+  Rejected: "rejected",
+} as const;
+/**
+ * Outcome of the most recent submit attempt, or null.
+ */
+export type LastSubmission = OpenEnum<typeof LastSubmission>;
+
+/**
+ * derive while the effective spec, build skeleton, and sandbox are prepared; build while the coding loop runs; assemble while an accepted artifact publishes.
+ */
+export const SimulatorBuildProgressStage = {
+  Derive: "derive",
+  Build: "build",
+  Assemble: "assemble",
+} as const;
+/**
+ * derive while the effective spec, build skeleton, and sandbox are prepared; build while the coding loop runs; assemble while an accepted artifact publishes.
+ */
+export type SimulatorBuildProgressStage = OpenEnum<
+  typeof SimulatorBuildProgressStage
+>;
+
+export type SimulatorBuildProgress = {
+  /**
+   * The coding-loop provider.
+   */
+  builder: SimulatorBuildProgressBuilder;
+  /**
+   * Outcome of the most recent submit attempt, or null.
+   */
+  lastSubmission: LastSubmission | null;
+  /**
+   * Name of the most recent tool call, or null.
+   */
+  lastTool: string | null;
+  /**
+   * derive while the effective spec, build skeleton, and sandbox are prepared; build while the coding loop runs; assemble while an accepted artifact publishes.
+   */
+  stage: SimulatorBuildProgressStage;
+  /**
+   * Submit attempts.
+   */
+  submissions: number;
+  /**
+   * Tool calls the coding loop executed.
+   */
+  toolCalls: number;
+  /**
+   * Time of the last progress report.
+   */
+  updatedAt: Date;
+};
+
+/** @internal */
+export const SimulatorBuildProgressBuilder$inboundSchema: z.ZodMiniType<
+  SimulatorBuildProgressBuilder,
+  unknown
+> = openEnums.inboundSchema(SimulatorBuildProgressBuilder);
+
+/** @internal */
+export const LastSubmission$inboundSchema: z.ZodMiniType<
+  LastSubmission,
+  unknown
+> = openEnums.inboundSchema(LastSubmission);
+
+/** @internal */
+export const SimulatorBuildProgressStage$inboundSchema: z.ZodMiniType<
+  SimulatorBuildProgressStage,
+  unknown
+> = openEnums.inboundSchema(SimulatorBuildProgressStage);
+
+/** @internal */
+export const SimulatorBuildProgress$inboundSchema: z.ZodMiniType<
+  SimulatorBuildProgress,
+  unknown
+> = z.pipe(
+  z.object({
+    builder: SimulatorBuildProgressBuilder$inboundSchema,
+    last_submission: types.nullable(LastSubmission$inboundSchema),
+    last_tool: types.nullable(types.string()),
+    stage: SimulatorBuildProgressStage$inboundSchema,
+    submissions: types.number(),
+    tool_calls: types.number(),
+    updated_at: types.date(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "last_submission": "lastSubmission",
+      "last_tool": "lastTool",
+      "tool_calls": "toolCalls",
+      "updated_at": "updatedAt",
+    });
+  }),
+);
+
+export function simulatorBuildProgressFromJSON(
+  jsonString: string,
+): SafeParseResult<SimulatorBuildProgress, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SimulatorBuildProgress$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SimulatorBuildProgress' from JSON`,
+  );
+}

package/src/models/simulator-error.ts

@@ -0,0 +1,59 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+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 * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+/**
+ * Stable Simulator build error code.
+ */
+export const SimulatorErrorCode = {
+  BuildFailed: "build_failed",
+  BuildCancelled: "build_cancelled",
+} as const;
+/**
+ * Stable Simulator build error code.
+ */
+export type SimulatorErrorCode = OpenEnum<typeof SimulatorErrorCode>;
+
+export type SimulatorError = {
+  /**
+   * Stable Simulator build error code.
+   */
+  code: SimulatorErrorCode;
+  /**
+   * Safe human-readable error detail.
+   */
+  detail: string;
+};
+
+/** @internal */
+export const SimulatorErrorCode$inboundSchema: z.ZodMiniType<
+  SimulatorErrorCode,
+  unknown
+> = openEnums.inboundSchema(SimulatorErrorCode);
+
+/** @internal */
+export const SimulatorError$inboundSchema: z.ZodMiniType<
+  SimulatorError,
+  unknown
+> = z.object({
+  code: SimulatorErrorCode$inboundSchema,
+  detail: types.string(),
+});
+
+export function simulatorErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<SimulatorError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SimulatorError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SimulatorError' from JSON`,
+  );
+}

package/src/models/simulator.ts

@@ -11,9 +11,13 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 import {
-  ResourceError,
-  ResourceError$inboundSchema,
-} from "./resource-error.js";
+  SimulatorBuildProgress,
+  SimulatorBuildProgress$inboundSchema,
+} from "./simulator-build-progress.js";
+import {
+  SimulatorError,
+  SimulatorError$inboundSchema,
+} from "./simulator-error.js";
 
 /**
  * workspace for a Simulator your workspace built; catalog for a read-only Simulator that Continuous publishes.
@@ -42,11 +46,15 @@ export const SimulatorStatus = {
 export type SimulatorStatus = OpenEnum<typeof SimulatorStatus>;
 
 export type Simulator = {
+  /**
+   * The build's latest progress report, or null before the first report. A terminal Simulator keeps its last report.
+   */
+  build: SimulatorBuildProgress | null;
   /**
    * Simulator creation time.
    */
   createdAt: Date;
-  error: ResourceError | null;
+  error: SimulatorError | null;
   /**
    * Simulator ID.
    */
@@ -83,8 +91,9 @@ export const SimulatorStatus$inboundSchema: z.ZodMiniType<
 export const Simulator$inboundSchema: z.ZodMiniType<Simulator, unknown> = z
   .pipe(
     z.object({
+      build: types.nullable(SimulatorBuildProgress$inboundSchema),
       created_at: types.date(),
-      error: types.nullable(ResourceError$inboundSchema),
+      error: types.nullable(SimulatorError$inboundSchema),
       id: types.string(),
       name: types.string(),
       parent_id: types.nullable(types.string()),

package/src/models/world-build.ts

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+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 * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  WorldDataSummary,
+  WorldDataSummary$inboundSchema,
+} from "./world-data-summary.js";
+
+/**
+ * Current phase of starting-data preparation.
+ */
+export const WorldBuildStage = {
+  Planning: "planning",
+  Generating: "generating",
+  Validating: "validating",
+  Complete: "complete",
+} as const;
+/**
+ * Current phase of starting-data preparation.
+ */
+export type WorldBuildStage = OpenEnum<typeof WorldBuildStage>;
+
+export type WorldBuild = {
+  /**
+   * Current phase of starting-data preparation.
+   */
+  stage: WorldBuildStage;
+  summary?: WorldDataSummary | undefined;
+};
+
+/** @internal */
+export const WorldBuildStage$inboundSchema: z.ZodMiniType<
+  WorldBuildStage,
+  unknown
+> = openEnums.inboundSchema(WorldBuildStage);
+
+/** @internal */
+export const WorldBuild$inboundSchema: z.ZodMiniType<WorldBuild, unknown> = z
+  .object({
+    stage: WorldBuildStage$inboundSchema,
+    summary: types.optional(WorldDataSummary$inboundSchema),
+  });
+
+export function worldBuildFromJSON(
+  jsonString: string,
+): SafeParseResult<WorldBuild, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WorldBuild$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WorldBuild' from JSON`,
+  );
+}

package/src/models/world-data-summary.ts

@@ -0,0 +1,53 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  WorldRecordCount,
+  WorldRecordCount$inboundSchema,
+} from "./world-record-count.js";
+
+export type WorldDataSummary = {
+  /**
+   * Defaults and inferred choices used to prepare the starting data.
+   */
+  assumptions: Array<string>;
+  /**
+   * Record conditions and counts computed from a complete census of served records.
+   */
+  conditions: Array<string>;
+  /**
+   * Observed starting record counts for each member and record type.
+   */
+  records: Array<WorldRecordCount>;
+  /**
+   * Shared relationships checked against the data and served API values.
+   */
+  relationships: Array<string>;
+};
+
+/** @internal */
+export const WorldDataSummary$inboundSchema: z.ZodMiniType<
+  WorldDataSummary,
+  unknown
+> = z.object({
+  assumptions: z.array(types.string()),
+  conditions: z.array(types.string()),
+  records: z.array(WorldRecordCount$inboundSchema),
+  relationships: z.array(types.string()),
+});
+
+export function worldDataSummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<WorldDataSummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WorldDataSummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WorldDataSummary' from JSON`,
+  );
+}

package/src/models/world-error.ts

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+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 * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+/**
+ * Stable World error code.
+ */
+export const WorldErrorCode = {
+  WorldBuildCanceled: "world_build_canceled",
+  WorldStartFailed: "world_start_failed",
+  WorldCreateFailed: "world_create_failed",
+  WorldFailed: "world_failed",
+  WorldPopulationFailed: "world_population_failed",
+  WorldPopulationUnsupported: "world_population_unsupported",
+  WorldPopulationInvalid: "world_population_invalid",
+  WorldPopulationUnavailable: "world_population_unavailable",
+} as const;
+/**
+ * Stable World error code.
+ */
+export type WorldErrorCode = OpenEnum<typeof WorldErrorCode>;
+
+export type WorldError = {
+  /**
+   * Stable World error code.
+   */
+  code: WorldErrorCode;
+  /**
+   * Safe human-readable error detail.
+   */
+  detail: string;
+};
+
+/** @internal */
+export const WorldErrorCode$inboundSchema: z.ZodMiniType<
+  WorldErrorCode,
+  unknown
+> = openEnums.inboundSchema(WorldErrorCode);
+
+/** @internal */
+export const WorldError$inboundSchema: z.ZodMiniType<WorldError, unknown> = z
+  .object({
+    code: WorldErrorCode$inboundSchema,
+    detail: types.string(),
+  });
+
+export function worldErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<WorldError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WorldError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WorldError' from JSON`,
+  );
+}

package/src/models/world-record-count.ts

@@ -0,0 +1,58 @@
+/*
+ * 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";
+
+export type WorldRecordCount = {
+  /**
+   * Number of stored starting records of this type.
+   */
+  count: number;
+  /**
+   * Record type reported by the Simulator.
+   */
+  entity: string;
+  /**
+   * Position in the selected Simulator list, starting at zero.
+   */
+  memberIndex: number;
+  /**
+   * Stable ID of the Simulator for this member.
+   */
+  simulatorId: string;
+};
+
+/** @internal */
+export const WorldRecordCount$inboundSchema: z.ZodMiniType<
+  WorldRecordCount,
+  unknown
+> = z.pipe(
+  z.object({
+    count: types.number(),
+    entity: types.string(),
+    member_index: types.number(),
+    simulator_id: types.string(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "member_index": "memberIndex",
+      "simulator_id": "simulatorId",
+    });
+  }),
+);
+
+export function worldRecordCountFromJSON(
+  jsonString: string,
+): SafeParseResult<WorldRecordCount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WorldRecordCount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WorldRecordCount' from JSON`,
+  );
+}