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

package/src/models/operations/add-device.ts

@@ -3,123 +3,49 @@
  */
 
 import * as z from "zod/v4-mini";
-import { safeParse } from "../../lib/schemas.js";
-import * as openEnums from "../../types/enums.js";
-import { ClosedEnum, OpenEnum } from "../../types/enums.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import * as types from "../../types/primitives.js";
-import { smartUnion } from "../../types/smart-union.js";
-import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import { ClosedEnum } from "../../types/enums.js";
 
-export const ScopeRequest = {
+export const AddDeviceScope = {
   Mobile: "mobile",
   Desktop: "desktop",
   Wildcard: "*",
   Any: "any",
   Unknown: "",
 } as const;
-export type ScopeRequest = ClosedEnum<typeof ScopeRequest>;
+export type AddDeviceScope = ClosedEnum<typeof AddDeviceScope>;
 
 export type AddDeviceRequest = {
   /**
    * Journey Instance Id, a unique identifier for a started journey instance.
    */
   instanceId: string;
-  scope: Array<ScopeRequest>;
+  scope?: Array<AddDeviceScope> | undefined;
+  [additionalProperties: string]: unknown;
 };
 
-export const AddDeviceTokenType2 = {
-  Bearer: "Bearer",
-  DPoP: "DPoP",
-  NA: "N_A",
-  Connect: "connect",
-} as const;
-export type AddDeviceTokenType2 = OpenEnum<typeof AddDeviceTokenType2>;
-
-export const ScopeResponse2 = {
-  Mobile: "mobile",
-  Desktop: "desktop",
-  Wildcard: "*",
-  Any: "any",
-  Unknown: "",
-} as const;
-export type ScopeResponse2 = OpenEnum<typeof ScopeResponse2>;
-
-/**
- * Success
- */
-export type AddDeviceResponseBody2 = {
-  /**
-   * Token used for subsequent operations by the client
-   */
-  connectToken: string;
-  tokenType: AddDeviceTokenType2;
-  /**
-   * Seconds until the token expires
-   */
-  expiresIn: number;
-  /**
-   * Scopes granted to the client
-   */
-  scope?: Array<ScopeResponse2> | undefined;
-};
-
-export const AddDeviceTokenType1 = {
-  Bearer: "Bearer",
-  DPoP: "DPoP",
-  NA: "N_A",
-  Connect: "connect",
-} as const;
-export type AddDeviceTokenType1 = OpenEnum<typeof AddDeviceTokenType1>;
-
-export const ScopeResponse1 = {
-  Mobile: "mobile",
-  Desktop: "desktop",
-  Wildcard: "*",
-  Any: "any",
-  Unknown: "",
-} as const;
-export type ScopeResponse1 = OpenEnum<typeof ScopeResponse1>;
-
-/**
- * Success
- */
-export type AddDeviceResponseBody1 = {
-  /**
-   * Token used for subsequent operations by the client
-   */
-  connectToken: string;
-  tokenType: AddDeviceTokenType1;
-  /**
-   * Seconds until the token expires
-   */
-  expiresIn: number;
-  /**
-   * Scopes granted to the client
-   */
-  scope?: Array<ScopeResponse1> | undefined;
-};
-
-export type AddDeviceResponse = AddDeviceResponseBody1 | AddDeviceResponseBody2;
-
 /** @internal */
-export const ScopeRequest$outboundSchema: z.ZodMiniEnum<typeof ScopeRequest> = z
-  .enum(ScopeRequest);
+export const AddDeviceScope$outboundSchema: z.ZodMiniEnum<
+  typeof AddDeviceScope
+> = z.enum(AddDeviceScope);
 
 /** @internal */
 export type AddDeviceRequest$Outbound = {
   instanceId: string;
-  scope: Array<string>;
+  scope?: Array<string> | undefined;
+  [additionalProperties: string]: unknown;
 };
 
 /** @internal */
 export const AddDeviceRequest$outboundSchema: z.ZodMiniType<
   AddDeviceRequest$Outbound,
   AddDeviceRequest
-> = z.object({
-  instanceId: z.string(),
-  scope: z.array(ScopeRequest$outboundSchema),
-});
+> = z.catchall(
+  z.object({
+    instanceId: z.string(),
+    scope: z.optional(z.array(AddDeviceScope$outboundSchema)),
+  }),
+  z.any(),
+);
 
 export function addDeviceRequestToJSON(
   addDeviceRequest: AddDeviceRequest,
@@ -128,88 +54,3 @@ export function addDeviceRequestToJSON(
     AddDeviceRequest$outboundSchema.parse(addDeviceRequest),
   );
 }
-
-/** @internal */
-export const AddDeviceTokenType2$inboundSchema: z.ZodMiniType<
-  AddDeviceTokenType2,
-  unknown
-> = openEnums.inboundSchema(AddDeviceTokenType2);
-
-/** @internal */
-export const ScopeResponse2$inboundSchema: z.ZodMiniType<
-  ScopeResponse2,
-  unknown
-> = openEnums.inboundSchema(ScopeResponse2);
-
-/** @internal */
-export const AddDeviceResponseBody2$inboundSchema: z.ZodMiniType<
-  AddDeviceResponseBody2,
-  unknown
-> = z.object({
-  connectToken: types.string(),
-  tokenType: z._default(AddDeviceTokenType2$inboundSchema, "Bearer"),
-  expiresIn: types.number(),
-  scope: types.optional(z.array(ScopeResponse2$inboundSchema)),
-});
-
-export function addDeviceResponseBody2FromJSON(
-  jsonString: string,
-): SafeParseResult<AddDeviceResponseBody2, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AddDeviceResponseBody2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AddDeviceResponseBody2' from JSON`,
-  );
-}
-
-/** @internal */
-export const AddDeviceTokenType1$inboundSchema: z.ZodMiniType<
-  AddDeviceTokenType1,
-  unknown
-> = openEnums.inboundSchema(AddDeviceTokenType1);
-
-/** @internal */
-export const ScopeResponse1$inboundSchema: z.ZodMiniType<
-  ScopeResponse1,
-  unknown
-> = openEnums.inboundSchema(ScopeResponse1);
-
-/** @internal */
-export const AddDeviceResponseBody1$inboundSchema: z.ZodMiniType<
-  AddDeviceResponseBody1,
-  unknown
-> = z.object({
-  connectToken: types.string(),
-  tokenType: z._default(AddDeviceTokenType1$inboundSchema, "Bearer"),
-  expiresIn: types.number(),
-  scope: types.optional(z.array(ScopeResponse1$inboundSchema)),
-});
-
-export function addDeviceResponseBody1FromJSON(
-  jsonString: string,
-): SafeParseResult<AddDeviceResponseBody1, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AddDeviceResponseBody1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AddDeviceResponseBody1' from JSON`,
-  );
-}
-
-/** @internal */
-export const AddDeviceResponse$inboundSchema: z.ZodMiniType<
-  AddDeviceResponse,
-  unknown
-> = smartUnion([
-  z.lazy(() => AddDeviceResponseBody1$inboundSchema),
-  z.lazy(() => AddDeviceResponseBody2$inboundSchema),
-]);
-
-export function addDeviceResponseFromJSON(
-  jsonString: string,
-): SafeParseResult<AddDeviceResponse, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AddDeviceResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AddDeviceResponse' from JSON`,
-  );
-}

package/src/models/operations/create-handoff-token.ts

@@ -0,0 +1,63 @@
+/*
+ * 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";
+
+export type CreateHandoffTokenSecurity = {
+  interactionAccess: string;
+};
+
+export type CreateHandoffTokenRequest = {
+  instanceId: string;
+};
+
+/** @internal */
+export type CreateHandoffTokenSecurity$Outbound = {
+  InteractionAccess: string;
+};
+
+/** @internal */
+export const CreateHandoffTokenSecurity$outboundSchema: z.ZodMiniType<
+  CreateHandoffTokenSecurity$Outbound,
+  CreateHandoffTokenSecurity
+> = z.pipe(
+  z.object({
+    interactionAccess: z.string(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      interactionAccess: "InteractionAccess",
+    });
+  }),
+);
+
+export function createHandoffTokenSecurityToJSON(
+  createHandoffTokenSecurity: CreateHandoffTokenSecurity,
+): string {
+  return JSON.stringify(
+    CreateHandoffTokenSecurity$outboundSchema.parse(createHandoffTokenSecurity),
+  );
+}
+
+/** @internal */
+export type CreateHandoffTokenRequest$Outbound = {
+  instanceId: string;
+};
+
+/** @internal */
+export const CreateHandoffTokenRequest$outboundSchema: z.ZodMiniType<
+  CreateHandoffTokenRequest$Outbound,
+  CreateHandoffTokenRequest
+> = z.object({
+  instanceId: z.string(),
+});
+
+export function createHandoffTokenRequestToJSON(
+  createHandoffTokenRequest: CreateHandoffTokenRequest,
+): string {
+  return JSON.stringify(
+    CreateHandoffTokenRequest$outboundSchema.parse(createHandoffTokenRequest),
+  );
+}

package/src/models/operations/create-sandbox-scenario.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as models from "../index.js";
+
+export type CreateSandboxScenarioRequest = {
+  /**
+   * Id of the journey the scenario belongs to. Scenarios are listed, read and resolved per journey.
+   */
+  journeyId: string;
+  body?: models.CreateSandboxScenarioRequest | undefined;
+};
+
+/** @internal */
+export type CreateSandboxScenarioRequest$Outbound = {
+  journeyId: string;
+  body?: models.CreateSandboxScenarioRequest$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateSandboxScenarioRequest$outboundSchema: z.ZodMiniType<
+  CreateSandboxScenarioRequest$Outbound,
+  CreateSandboxScenarioRequest
+> = z.object({
+  journeyId: z.string(),
+  body: z.optional(models.CreateSandboxScenarioRequest$outboundSchema),
+});
+
+export function createSandboxScenarioRequestToJSON(
+  createSandboxScenarioRequest: CreateSandboxScenarioRequest,
+): string {
+  return JSON.stringify(
+    CreateSandboxScenarioRequest$outboundSchema.parse(
+      createSandboxScenarioRequest,
+    ),
+  );
+}

package/src/models/operations/delete-instance.ts

@@ -3,67 +3,36 @@
  */
 
 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 DeleteInstanceRequest = {
   /**
    * Journey Instance Id, a unique identifier for a started journey instance.
    */
   instanceId: string;
-};
-
-/**
- * Delete instance response contains the Journey Instance Id
- */
-export type DeleteInstanceResponse = {
-  /**
-   * Journey Instance Id, a unique identifier for a started journey instance.
-   */
-  instanceId: string;
   [additionalProperties: string]: unknown;
 };
 
 /** @internal */
 export type DeleteInstanceRequest$Outbound = {
   instanceId: string;
+  [additionalProperties: string]: unknown;
 };
 
 /** @internal */
 export const DeleteInstanceRequest$outboundSchema: z.ZodMiniType<
   DeleteInstanceRequest$Outbound,
   DeleteInstanceRequest
-> = z.object({
-  instanceId: z.string(),
-});
-
-export function deleteInstanceRequestToJSON(
-  deleteInstanceRequest: DeleteInstanceRequest,
-): string {
-  return JSON.stringify(
-    DeleteInstanceRequest$outboundSchema.parse(deleteInstanceRequest),
-  );
-}
-
-/** @internal */
-export const DeleteInstanceResponse$inboundSchema: z.ZodMiniType<
-  DeleteInstanceResponse,
-  unknown
 > = z.catchall(
   z.object({
-    instanceId: types.string(),
+    instanceId: z.string(),
   }),
   z.any(),
 );
 
-export function deleteInstanceResponseFromJSON(
-  jsonString: string,
-): SafeParseResult<DeleteInstanceResponse, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => DeleteInstanceResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DeleteInstanceResponse' from JSON`,
+export function deleteInstanceRequestToJSON(
+  deleteInstanceRequest: DeleteInstanceRequest,
+): string {
+  return JSON.stringify(
+    DeleteInstanceRequest$outboundSchema.parse(deleteInstanceRequest),
   );
 }

package/src/models/operations/delete-sandbox-scenario.ts

@@ -0,0 +1,41 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type DeleteSandboxScenarioRequest = {
+  /**
+   * Id of the journey the scenario belongs to. Scenarios are listed, read and resolved per journey.
+   */
+  journeyId: string;
+  /**
+   * Scenario identifier, unique per journey (GGO-18332). The same name may exist on other journeys of the org with different content.
+   */
+  name: string;
+};
+
+/** @internal */
+export type DeleteSandboxScenarioRequest$Outbound = {
+  journeyId: string;
+  name: string;
+};
+
+/** @internal */
+export const DeleteSandboxScenarioRequest$outboundSchema: z.ZodMiniType<
+  DeleteSandboxScenarioRequest$Outbound,
+  DeleteSandboxScenarioRequest
+> = z.object({
+  journeyId: z.string(),
+  name: z.string(),
+});
+
+export function deleteSandboxScenarioRequestToJSON(
+  deleteSandboxScenarioRequest: DeleteSandboxScenarioRequest,
+): string {
+  return JSON.stringify(
+    DeleteSandboxScenarioRequest$outboundSchema.parse(
+      deleteSandboxScenarioRequest,
+    ),
+  );
+}

package/src/models/operations/device-connect.ts

@@ -4,13 +4,6 @@
 
 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 { smartUnion } from "../../types/smart-union.js";
-import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
 export type DeviceConnectSecurity = {
   deviceConnect: string;
@@ -33,56 +26,6 @@ export type DeviceConnectRequest = {
   deviceInfo: DeviceInfo;
 };
 
-export const DeviceConnectTokenType2 = {
-  Bearer: "Bearer",
-  DPoP: "DPoP",
-  NA: "N_A",
-  EndUser: "end-user",
-} as const;
-export type DeviceConnectTokenType2 = OpenEnum<typeof DeviceConnectTokenType2>;
-
-/**
- * Success
- */
-export type DeviceConnectResponseBody2 = {
-  /**
-   * Token used for subsequent operations by the client
-   */
-  endUserToken?: string | undefined;
-  tokenType: DeviceConnectTokenType2;
-  /**
-   * Seconds until the token expires
-   */
-  expiresIn: number;
-};
-
-export const DeviceConnectTokenType1 = {
-  Bearer: "Bearer",
-  DPoP: "DPoP",
-  NA: "N_A",
-  EndUser: "end-user",
-} as const;
-export type DeviceConnectTokenType1 = OpenEnum<typeof DeviceConnectTokenType1>;
-
-/**
- * Success
- */
-export type DeviceConnectResponseBody1 = {
-  /**
-   * Token used for subsequent operations by the client
-   */
-  endUserToken?: string | undefined;
-  tokenType: DeviceConnectTokenType1;
-  /**
-   * Seconds until the token expires
-   */
-  expiresIn: number;
-};
-
-export type DeviceConnectResponse =
-  | DeviceConnectResponseBody1
-  | DeviceConnectResponseBody2;
-
 /** @internal */
 export type DeviceConnectSecurity$Outbound = {
   DeviceConnect: string;
@@ -154,74 +97,3 @@ export function deviceConnectRequestToJSON(
     DeviceConnectRequest$outboundSchema.parse(deviceConnectRequest),
   );
 }
-
-/** @internal */
-export const DeviceConnectTokenType2$inboundSchema: z.ZodMiniType<
-  DeviceConnectTokenType2,
-  unknown
-> = openEnums.inboundSchema(DeviceConnectTokenType2);
-
-/** @internal */
-export const DeviceConnectResponseBody2$inboundSchema: z.ZodMiniType<
-  DeviceConnectResponseBody2,
-  unknown
-> = z.object({
-  endUserToken: types.optional(types.string()),
-  tokenType: z._default(DeviceConnectTokenType2$inboundSchema, "Bearer"),
-  expiresIn: types.number(),
-});
-
-export function deviceConnectResponseBody2FromJSON(
-  jsonString: string,
-): SafeParseResult<DeviceConnectResponseBody2, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => DeviceConnectResponseBody2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DeviceConnectResponseBody2' from JSON`,
-  );
-}
-
-/** @internal */
-export const DeviceConnectTokenType1$inboundSchema: z.ZodMiniType<
-  DeviceConnectTokenType1,
-  unknown
-> = openEnums.inboundSchema(DeviceConnectTokenType1);
-
-/** @internal */
-export const DeviceConnectResponseBody1$inboundSchema: z.ZodMiniType<
-  DeviceConnectResponseBody1,
-  unknown
-> = z.object({
-  endUserToken: types.optional(types.string()),
-  tokenType: z._default(DeviceConnectTokenType1$inboundSchema, "Bearer"),
-  expiresIn: types.number(),
-});
-
-export function deviceConnectResponseBody1FromJSON(
-  jsonString: string,
-): SafeParseResult<DeviceConnectResponseBody1, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => DeviceConnectResponseBody1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DeviceConnectResponseBody1' from JSON`,
-  );
-}
-
-/** @internal */
-export const DeviceConnectResponse$inboundSchema: z.ZodMiniType<
-  DeviceConnectResponse,
-  unknown
-> = smartUnion([
-  z.lazy(() => DeviceConnectResponseBody1$inboundSchema),
-  z.lazy(() => DeviceConnectResponseBody2$inboundSchema),
-]);
-
-export function deviceConnectResponseFromJSON(
-  jsonString: string,
-): SafeParseResult<DeviceConnectResponse, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => DeviceConnectResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'DeviceConnectResponse' from JSON`,
-  );
-}

package/src/models/operations/device-validate.ts

@@ -0,0 +1,38 @@
+/*
+ * 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";
+
+export type DeviceValidateSecurity = {
+  interactionAccess: string;
+};
+
+/** @internal */
+export type DeviceValidateSecurity$Outbound = {
+  InteractionAccess: string;
+};
+
+/** @internal */
+export const DeviceValidateSecurity$outboundSchema: z.ZodMiniType<
+  DeviceValidateSecurity$Outbound,
+  DeviceValidateSecurity
+> = z.pipe(
+  z.object({
+    interactionAccess: z.string(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      interactionAccess: "InteractionAccess",
+    });
+  }),
+);
+
+export function deviceValidateSecurityToJSON(
+  deviceValidateSecurity: DeviceValidateSecurity,
+): string {
+  return JSON.stringify(
+    DeviceValidateSecurity$outboundSchema.parse(deviceValidateSecurity),
+  );
+}