@gbg/go-core 0.2.0-alpha.0 → 0.2.0-alpha.2

package/src/models/slim-validation.ts

@@ -5,7 +5,6 @@
 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";
 
 export type ValidationCheckBoundingBox = {
@@ -66,10 +65,10 @@ export const ValidationCheckBoundingBox$inboundSchema: z.ZodMiniType<
   ValidationCheckBoundingBox,
   unknown
 > = z.object({
-  x: types.number(),
-  y: types.number(),
-  width: types.number(),
-  height: types.number(),
+  x: z.number(),
+  y: z.number(),
+  width: z.number(),
+  height: z.number(),
 });
 
 export function validationCheckBoundingBoxFromJSON(
@@ -87,12 +86,12 @@ export const ValidationCheckRegionOfInterest$inboundSchema: z.ZodMiniType<
   ValidationCheckRegionOfInterest,
   unknown
 > = z.object({
-  boundingBox: types.optional(
+  boundingBox: z.optional(
     z.lazy(() => ValidationCheckBoundingBox$inboundSchema),
   ),
-  side: types.string(),
-  spectrum: types.optional(types.string()),
-  imageId: types.optional(types.string()),
+  side: z.string(),
+  spectrum: z.optional(z.string()),
+  imageId: z.optional(z.string()),
 });
 
 export function validationCheckRegionOfInterestFromJSON(
@@ -110,14 +109,14 @@ export const ValidationCheck$inboundSchema: z.ZodMiniType<
   ValidationCheck,
   unknown
 > = z.object({
-  name: types.string(),
-  title: types.string(),
-  validationResult: types.string(),
-  weight: types.string(),
-  regionOfInterests: types.optional(
+  name: z.string(),
+  title: z.string(),
+  validationResult: z.string(),
+  weight: z.string(),
+  regionOfInterests: z.optional(
     z.array(z.lazy(() => ValidationCheckRegionOfInterest$inboundSchema)),
   ),
-  type: types.string(),
+  type: z.string(),
 });
 
 export function validationCheckFromJSON(
@@ -135,10 +134,10 @@ export const AggregatedValidationCheckBoundingBox$inboundSchema: z.ZodMiniType<
   AggregatedValidationCheckBoundingBox,
   unknown
 > = z.object({
-  x: types.number(),
-  y: types.number(),
-  width: types.number(),
-  height: types.number(),
+  x: z.number(),
+  y: z.number(),
+  width: z.number(),
+  height: z.number(),
 });
 
 export function aggregatedValidationCheckBoundingBoxFromJSON(
@@ -155,12 +154,12 @@ export function aggregatedValidationCheckBoundingBoxFromJSON(
 /** @internal */
 export const AggregatedValidationCheckRegionOfInterest$inboundSchema:
   z.ZodMiniType<AggregatedValidationCheckRegionOfInterest, unknown> = z.object({
-    boundingBox: types.optional(
+    boundingBox: z.optional(
       z.lazy(() => AggregatedValidationCheckBoundingBox$inboundSchema),
     ),
-    side: types.string(),
-    spectrum: types.optional(types.string()),
-    imageId: types.optional(types.string()),
+    side: z.string(),
+    spectrum: z.optional(z.string()),
+    imageId: z.optional(z.string()),
   });
 
 export function aggregatedValidationCheckRegionOfInterestFromJSON(
@@ -184,16 +183,16 @@ export const AggregatedValidationCheck$inboundSchema: z.ZodMiniType<
   AggregatedValidationCheck,
   unknown
 > = z.object({
-  name: types.string(),
-  title: types.string(),
-  validationResult: types.string(),
-  weight: types.string(),
-  regionOfInterests: types.optional(
+  name: z.string(),
+  title: z.string(),
+  validationResult: z.string(),
+  weight: z.string(),
+  regionOfInterests: z.optional(
     z.array(
       z.lazy(() => AggregatedValidationCheckRegionOfInterest$inboundSchema),
     ),
   ),
-  type: types.string(),
+  type: z.string(),
 });
 
 export function aggregatedValidationCheckFromJSON(
@@ -211,10 +210,10 @@ export const SlimValidation$inboundSchema: z.ZodMiniType<
   SlimValidation,
   unknown
 > = z.object({
-  validationChecks: types.optional(
+  validationChecks: z.optional(
     z.array(z.lazy(() => ValidationCheck$inboundSchema)),
   ),
-  aggregatedValidationChecks: types.optional(
+  aggregatedValidationChecks: z.optional(
     z.array(z.lazy(() => AggregatedValidationCheck$inboundSchema)),
   ),
 });

package/src/models/slim-verified-data.ts

@@ -5,7 +5,6 @@
 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 { SlimDocument, SlimDocument$inboundSchema } from "./slim-document.js";
 import { SlimIdentity, SlimIdentity$inboundSchema } from "./slim-identity.js";
@@ -23,8 +22,8 @@ export const SlimVerifiedData$inboundSchema: z.ZodMiniType<
   SlimVerifiedData,
   unknown
 > = z.object({
-  identity: types.optional(SlimIdentity$inboundSchema),
-  documents: types.optional(z.array(SlimDocument$inboundSchema)),
+  identity: z.optional(SlimIdentity$inboundSchema),
+  documents: z.optional(z.array(SlimDocument$inboundSchema)),
 });
 
 export function slimVerifiedDataFromJSON(

package/src/models/state-fetch-response.ts

@@ -4,26 +4,38 @@
 
 import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } 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";
 
+export const ViewEnum = {
+  Full: "full",
+} as const;
+export type ViewEnum = ClosedEnum<typeof ViewEnum>;
+
 export type StateFetchResponse = {
+  view: ViewEnum;
   instanceId: string;
   status: string;
   context?: { [k: string]: any } | undefined;
   result?: { [k: string]: any } | undefined;
 };
 
+/** @internal */
+export const ViewEnum$inboundSchema: z.ZodMiniEnum<typeof ViewEnum> = z.enum(
+  ViewEnum,
+);
+
 /** @internal */
 export const StateFetchResponse$inboundSchema: z.ZodMiniType<
   StateFetchResponse,
   unknown
 > = z.object({
-  instanceId: types.string(),
-  status: types.string(),
-  context: types.optional(z.record(z.string(), z.any())),
-  result: types.optional(z.record(z.string(), z.any())),
+  view: ViewEnum$inboundSchema,
+  instanceId: z.string(),
+  status: z.string(),
+  context: z.optional(z.record(z.string(), z.any())),
+  result: z.optional(z.record(z.string(), z.any())),
 });
 
 export function stateFetchResponseFromJSON(

package/src/models/terminate-response.ts

@@ -5,7 +5,6 @@
 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";
 
 export type TerminateResponse = {
@@ -17,7 +16,7 @@ export const TerminateResponse$inboundSchema: z.ZodMiniType<
   TerminateResponse,
   unknown
 > = z.object({
-  instanceId: types.string(),
+  instanceId: z.string(),
 });
 
 export function terminateResponseFromJSON(

package/src/models/test-scenario-summary.ts

@@ -0,0 +1,62 @@
+/*
+ * 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 { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export const TestScenarioSummaryTier = {
+  Platform: "platform",
+  Org: "org",
+} as const;
+export type TestScenarioSummaryTier = OpenEnum<typeof TestScenarioSummaryTier>;
+
+export type TestScenarioSummary = {
+  name: string;
+  tier: TestScenarioSummaryTier;
+  editable: boolean;
+  description?: string | undefined;
+  /**
+   * When the scenario was last saved (ISO 8601).
+   */
+  lastModifiedTime?: Date | undefined;
+  /**
+   * Principal (JWT sub) who last saved the scenario.
+   */
+  lastModifiedBy?: string | undefined;
+};
+
+/** @internal */
+export const TestScenarioSummaryTier$inboundSchema: z.ZodMiniType<
+  TestScenarioSummaryTier,
+  unknown
+> = openEnums.inboundSchema(TestScenarioSummaryTier);
+
+/** @internal */
+export const TestScenarioSummary$inboundSchema: z.ZodMiniType<
+  TestScenarioSummary,
+  unknown
+> = z.object({
+  name: z.string(),
+  tier: TestScenarioSummaryTier$inboundSchema,
+  editable: z.boolean(),
+  description: z.optional(z.string()),
+  lastModifiedTime: z.optional(
+    z.pipe(z.iso.datetime({ offset: true }), z.transform(v => new Date(v))),
+  ),
+  lastModifiedBy: z.optional(z.string()),
+});
+
+export function testScenarioSummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<TestScenarioSummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TestScenarioSummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TestScenarioSummary' from JSON`,
+  );
+}

package/src/models/test-scenario-written.ts

@@ -0,0 +1,47 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export const TestScenarioWrittenTier = {
+  Org: "org",
+} as const;
+export type TestScenarioWrittenTier = ClosedEnum<
+  typeof TestScenarioWrittenTier
+>;
+
+export type TestScenarioWritten = {
+  name: string;
+  journeyId: string;
+  tier: TestScenarioWrittenTier;
+};
+
+/** @internal */
+export const TestScenarioWrittenTier$inboundSchema: z.ZodMiniEnum<
+  typeof TestScenarioWrittenTier
+> = z.enum(TestScenarioWrittenTier);
+
+/** @internal */
+export const TestScenarioWritten$inboundSchema: z.ZodMiniType<
+  TestScenarioWritten,
+  unknown
+> = z.object({
+  name: z.string(),
+  journeyId: z.string(),
+  tier: TestScenarioWrittenTier$inboundSchema,
+});
+
+export function testScenarioWrittenFromJSON(
+  jsonString: string,
+): SafeParseResult<TestScenarioWritten, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TestScenarioWritten$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TestScenarioWritten' from JSON`,
+  );
+}

package/src/models/test-scenario.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 { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export const TestScenarioTier = {
+  Platform: "platform",
+  Org: "org",
+} as const;
+export type TestScenarioTier = OpenEnum<typeof TestScenarioTier>;
+
+export type TestScenario = {
+  name: string;
+  journeyId: string;
+  tier: TestScenarioTier;
+  data: { [k: string]: any };
+  /**
+   * When the scenario was last saved (ISO 8601).
+   */
+  lastModifiedTime?: Date | undefined;
+  /**
+   * Principal (JWT sub) who last saved the scenario.
+   */
+  lastModifiedBy?: string | undefined;
+};
+
+/** @internal */
+export const TestScenarioTier$inboundSchema: z.ZodMiniType<
+  TestScenarioTier,
+  unknown
+> = openEnums.inboundSchema(TestScenarioTier);
+
+/** @internal */
+export const TestScenario$inboundSchema: z.ZodMiniType<TestScenario, unknown> =
+  z.object({
+    name: z.string(),
+    journeyId: z.string(),
+    tier: TestScenarioTier$inboundSchema,
+    data: z.record(z.string(), z.any()),
+    lastModifiedTime: z.optional(
+      z.pipe(z.iso.datetime({ offset: true }), z.transform(v => new Date(v))),
+    ),
+    lastModifiedBy: z.optional(z.string()),
+  });
+
+export function testScenarioFromJSON(
+  jsonString: string,
+): SafeParseResult<TestScenario, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TestScenario$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TestScenario' from JSON`,
+  );
+}

package/src/models/update-test-scenario-request.ts

@@ -0,0 +1,57 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+/**
+ * Scenario payload (ScenarioPayload). Requires `modules`, keyed by journey graph node id (GGO-18452 / GGO-16394); optionally `defaultOutcome`, `defaultSubject`, `description`, and extra passthrough fields. Validated by the store against the same schema the test scenario runtime enforces, so an accepted document is guaranteed runnable.
+ */
+export type UpdateTestScenarioRequestData = {};
+
+export type UpdateTestScenarioRequest = {
+  /**
+   * Scenario payload (ScenarioPayload). Requires `modules`, keyed by journey graph node id (GGO-18452 / GGO-16394); optionally `defaultOutcome`, `defaultSubject`, `description`, and extra passthrough fields. Validated by the store against the same schema the test scenario runtime enforces, so an accepted document is guaranteed runnable.
+   */
+  data: UpdateTestScenarioRequestData;
+};
+
+/** @internal */
+export type UpdateTestScenarioRequestData$Outbound = {};
+
+/** @internal */
+export const UpdateTestScenarioRequestData$outboundSchema: z.ZodMiniType<
+  UpdateTestScenarioRequestData$Outbound,
+  UpdateTestScenarioRequestData
+> = z.object({});
+
+export function updateTestScenarioRequestDataToJSON(
+  updateTestScenarioRequestData: UpdateTestScenarioRequestData,
+): string {
+  return JSON.stringify(
+    UpdateTestScenarioRequestData$outboundSchema.parse(
+      updateTestScenarioRequestData,
+    ),
+  );
+}
+
+/** @internal */
+export type UpdateTestScenarioRequest$Outbound = {
+  data: UpdateTestScenarioRequestData$Outbound;
+};
+
+/** @internal */
+export const UpdateTestScenarioRequest$outboundSchema: z.ZodMiniType<
+  UpdateTestScenarioRequest$Outbound,
+  UpdateTestScenarioRequest
+> = z.object({
+  data: z.lazy(() => UpdateTestScenarioRequestData$outboundSchema),
+});
+
+export function updateTestScenarioRequestToJSON(
+  updateTestScenarioRequest: UpdateTestScenarioRequest,
+): string {
+  return JSON.stringify(
+    UpdateTestScenarioRequest$outboundSchema.parse(updateTestScenarioRequest),
+  );
+}

package/src/sdk/devices.ts

@@ -37,7 +37,7 @@ export class Devices extends ClientSDK {
    */
   async connect(
     security: operations.DeviceConnectSecurity,
-    request: operations.DeviceConnectRequest,
+    request?: models.DeviceConnectRequest | undefined,
     options?: RequestOptions,
   ): Promise<models.DeviceConnectResponse> {
     return unwrapAsync(devicesConnect(

package/src/sdk/sdk.ts

@@ -8,8 +8,8 @@ import { Devices } from "./devices.js";
 import { Instances } from "./instances.js";
 import { Interactions } from "./interactions.js";
 import { Journeys } from "./journeys.js";
-import { Sandbox } from "./sandbox.js";
 import { Tasks } from "./tasks.js";
+import { TestScenarios } from "./test-scenarios.js";
 import { Tokens } from "./tokens.js";
 
 export class Go extends ClientSDK {
@@ -43,9 +43,9 @@ export class Go extends ClientSDK {
     return (this._devices ??= new Devices(this._options));
   }
 
-  private _sandbox?: Sandbox;
-  get sandbox(): Sandbox {
-    return (this._sandbox ??= new Sandbox(this._options));
+  private _testScenarios?: TestScenarios;
+  get testScenarios(): TestScenarios {
+    return (this._testScenarios ??= new TestScenarios(this._options));
   }
 
   private _tokens?: Tokens;

package/src/sdk/test-scenarios.ts

@@ -0,0 +1,100 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { testScenariosCreate } from "../funcs/test-scenarios-create.js";
+import { testScenariosDelete } from "../funcs/test-scenarios-delete.js";
+import { testScenariosGet } from "../funcs/test-scenarios-get.js";
+import { testScenariosList } from "../funcs/test-scenarios-list.js";
+import { testScenariosPut } from "../funcs/test-scenarios-put.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class TestScenarios extends ClientSDK {
+  /**
+   * Create a test scenario on a journey
+   *
+   * @remarks
+   * Creates an org-tier test scenario belonging to the journey in the path. Returns 409 if the name is taken on that journey (the same name may exist on other journeys). The scenario is resolvable at journey-start, for runs of that journey only, via the x-gbg-scenario header. Org is taken from the token.
+   */
+  async create(
+    request: operations.CreateTestScenarioRequest,
+    options?: RequestOptions,
+  ): Promise<models.TestScenarioWritten> {
+    return unwrapAsync(testScenariosCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List a journey's test scenarios
+   *
+   * @remarks
+   * Lists the org's test scenarios belonging to the journey in the path — never another journey's. Pass includePlatform=true to also return read-only GBG-provided platform scenarios (available on every journey); an org scenario shadows a platform scenario of the same name.
+   */
+  async list(
+    request: operations.ListTestScenariosRequest,
+    options?: RequestOptions,
+  ): Promise<Array<models.TestScenarioSummary>> {
+    return unwrapAsync(testScenariosList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Read a test scenario
+   *
+   * @remarks
+   * Reads one org-tier test scenario of the journey in the path. By default does not fall back to the platform tier or to another journey, so a name that exists only at platform level, or only on another journey, returns 404. Pass includePlatform=true to fall back to the read-only GBG-provided scenario of that name; the response `tier` says which tier served it. Another journey is never consulted either way.
+   */
+  async get(
+    request: operations.GetTestScenarioRequest,
+    options?: RequestOptions,
+  ): Promise<models.TestScenario> {
+    return unwrapAsync(testScenariosGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Replace a test scenario
+   *
+   * @remarks
+   * Replaces an existing org-tier test scenario of the journey in the path. Returns 404 if it does not exist on that journey — use POST to create. Requires UPDATE:journey; creating (POST) requires CREATE:journey, so an edit-only grant cannot mint new scenarios through this endpoint.
+   */
+  async put(
+    request: operations.PutTestScenarioRequest,
+    options?: RequestOptions,
+  ): Promise<models.TestScenarioWritten> {
+    return unwrapAsync(testScenariosPut(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a test scenario
+   *
+   * @remarks
+   * Deletes an org-tier test scenario of the journey in the path by archiving it: it disappears from listings and journey-start resolution, but its version history is retained and creating the same name again restores it. A platform scenario of the same name, previously shadowed by this one on this journey, becomes resolvable again at journey-start.
+   */
+  async delete(
+    request: operations.DeleteTestScenarioRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(testScenariosDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/types/discriminated-union.ts

@@ -0,0 +1,98 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { startCountingUnrecognized } from "./unrecognized.js";
+
+const UNKNOWN = Symbol("UNKNOWN");
+
+export type Unknown<Discriminator extends string, UnknownValue = "UNKNOWN"> =
+  & {
+    [K in Discriminator]: UnknownValue;
+  }
+  & {
+    raw: unknown;
+    isUnknown: true;
+  };
+
+export function isUnknown<Discriminator extends string>(
+  value: unknown,
+): value is Unknown<Discriminator> {
+  return typeof value === "object" && value !== null && UNKNOWN in value;
+}
+
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export function discriminatedUnion<
+  InputDiscriminator extends string,
+  TOptions extends Readonly<Record<string, z.ZodMiniType>>,
+  UnknownValue extends string = "UNKNOWN",
+  OutputDiscriminator extends string = InputDiscriminator,
+>(
+  inputPropertyName: InputDiscriminator,
+  options: TOptions,
+  opts: {
+    unknownValue?: UnknownValue;
+    outputPropertyName?: OutputDiscriminator;
+  } = {},
+): z.ZodMiniType<
+  | z.output<TOptions[keyof TOptions]>
+  | Unknown<OutputDiscriminator, UnknownValue>,
+  unknown
+> {
+  const { unknownValue = "UNKNOWN" as UnknownValue, outputPropertyName } = opts;
+  return z.pipe(
+    z.unknown(),
+    z.transform((input) => {
+      const fallback = Object.defineProperties(
+        {
+          raw: input,
+          [outputPropertyName ?? inputPropertyName]: unknownValue,
+          isUnknown: true as const,
+        },
+        { [UNKNOWN]: { value: true, enumerable: false, configurable: false } },
+      );
+
+      const isObject = typeof input === "object" && input !== null;
+      if (!isObject) return fallback;
+
+      const discriminator = input[inputPropertyName as keyof typeof input];
+      if (typeof discriminator !== "string") return fallback;
+      if (!(discriminator in options)) return fallback;
+
+      const schema = options[discriminator];
+      if (!schema) return fallback;
+
+      // Start counters before parsing to track nested unrecognized/zeroDefault values
+      const unrecognizedCtr = startCountingUnrecognized();
+
+      const result = z.safeParse(schema, input);
+      if (!result.success) {
+        // Parse failed - don't propagate any counts from the failed attempt
+        unrecognizedCtr.end(0);
+
+        return fallback;
+      }
+
+      // Parse succeeded - propagate the actual counts
+      unrecognizedCtr.end();
+
+      if (outputPropertyName) {
+        (result.data as any)[outputPropertyName] = discriminator;
+      }
+
+      return result.data;
+    }),
+  ) as any;
+}

package/src/types/index.ts

@@ -3,11 +3,9 @@
  */
 
 export { blobLikeSchema, isBlobLike } from "./blobs.js";
-export * from "./default-to-zero-value.js";
 export type { ClosedEnum, OpenEnum } from "./enums.js";
 export type { Result } from "./fp.js";
 export type { PageIterator, Paginator } from "./operations.js";
 export { createPageIterator } from "./operations.js";
-export * from "./primitives.js";
 export { RFCDate } from "./rfcdate.js";
 export * from "./unrecognized.js";