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

package/src/models/device-refresh-response.ts

@@ -0,0 +1,43 @@
+/*
+ * 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";
+
+export type DeviceRefreshResponse = {
+  endUserToken: string;
+  expiresIn: number;
+  instanceId: string;
+  resumeCredential: string;
+  credentialExpiresAt: string;
+  credentialExpiresIn: number;
+  linkExpiresAt: string;
+};
+
+/** @internal */
+export const DeviceRefreshResponse$inboundSchema: z.ZodMiniType<
+  DeviceRefreshResponse,
+  unknown
+> = z.object({
+  endUserToken: types.string(),
+  expiresIn: types.number(),
+  instanceId: types.string(),
+  resumeCredential: types.string(),
+  credentialExpiresAt: types.string(),
+  credentialExpiresIn: types.number(),
+  linkExpiresAt: types.string(),
+});
+
+export function deviceRefreshResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeviceRefreshResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeviceRefreshResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeviceRefreshResponse' from JSON`,
+  );
+}

package/src/models/device-start-response.ts

@@ -0,0 +1,50 @@
+/*
+ * 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 * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export const DeviceStartResponseTokenType = {
+  Connect: "connect",
+} as const;
+export type DeviceStartResponseTokenType = ClosedEnum<
+  typeof DeviceStartResponseTokenType
+>;
+
+export type DeviceStartResponse = {
+  connectToken: string;
+  tokenType: DeviceStartResponseTokenType;
+  expiresIn: number;
+  scope: Array<string>;
+};
+
+/** @internal */
+export const DeviceStartResponseTokenType$inboundSchema: z.ZodMiniEnum<
+  typeof DeviceStartResponseTokenType
+> = z.enum(DeviceStartResponseTokenType);
+
+/** @internal */
+export const DeviceStartResponse$inboundSchema: z.ZodMiniType<
+  DeviceStartResponse,
+  unknown
+> = z.object({
+  connectToken: types.string(),
+  tokenType: DeviceStartResponseTokenType$inboundSchema,
+  expiresIn: types.number(),
+  scope: z.array(types.string()),
+});
+
+export function deviceStartResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeviceStartResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeviceStartResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeviceStartResponse' from JSON`,
+  );
+}

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

@@ -0,0 +1,39 @@
+/*
+ * 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";
+
+export type DeviceValidateResponse = {
+  valid: true;
+  sessionId: string;
+  instanceId: string;
+  orgId: string;
+  expiresAt: string;
+};
+
+/** @internal */
+export const DeviceValidateResponse$inboundSchema: z.ZodMiniType<
+  DeviceValidateResponse,
+  unknown
+> = z.object({
+  valid: types.literal(true),
+  sessionId: types.string(),
+  instanceId: types.string(),
+  orgId: types.string(),
+  expiresAt: types.string(),
+});
+
+export function deviceValidateResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeviceValidateResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeviceValidateResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeviceValidateResponse' from JSON`,
+  );
+}

package/src/models/errors/error-response.ts

@@ -0,0 +1,52 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as models from "../index.js";
+import { GoError } from "./go-error.js";
+
+export type ErrorResponseData = {
+  errors: Array<models.GbgError>;
+};
+
+export class ErrorResponse extends GoError {
+  errors: Array<models.GbgError>;
+
+  /** The original data that was passed to this error instance. */
+  data$: ErrorResponseData;
+
+  constructor(
+    err: ErrorResponseData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = "message" in err && typeof err.message === "string"
+      ? err.message
+      : `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.errors = err.errors;
+
+    this.name = "ErrorResponse";
+  }
+}
+
+/** @internal */
+export const ErrorResponse$inboundSchema: z.ZodMiniType<
+  ErrorResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    errors: z.array(models.GbgError$inboundSchema),
+    request$: z.custom<Request>(x => x instanceof Request),
+    response$: z.custom<Response>(x => x instanceof Response),
+    body$: z.string(),
+  }),
+  z.transform((v) => {
+    return new ErrorResponse(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  }),
+);

package/src/models/errors/index.ts

@@ -2,6 +2,7 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+export * from "./error-response.js";
 export * from "./go-default-error.js";
 export * from "./go-error.js";
 export * from "./http-client-errors.js";

package/src/models/gbg-error.ts

@@ -0,0 +1,55 @@
+/*
+ * 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";
+
+export const LocationEnum = {
+  Path: "Path",
+  Authorization: "Authorization",
+  Header: "Header",
+  QueryString: "Query String",
+  Request: "Request",
+  Body: "Body",
+  Service: "Service",
+  Flow: "Flow",
+} as const;
+export type LocationEnum = OpenEnum<typeof LocationEnum>;
+
+export type GbgError = {
+  code: string;
+  name: string;
+  problem: string;
+  action: string;
+  location?: LocationEnum | undefined;
+};
+
+/** @internal */
+export const LocationEnum$inboundSchema: z.ZodMiniType<LocationEnum, unknown> =
+  openEnums.inboundSchema(LocationEnum);
+
+/** @internal */
+export const GbgError$inboundSchema: z.ZodMiniType<GbgError, unknown> = z
+  .object({
+    code: types.string(),
+    name: types.string(),
+    problem: types.string(),
+    action: types.string(),
+    location: types.optional(LocationEnum$inboundSchema),
+  });
+
+export function gbgErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<GbgError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GbgError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GbgError' from JSON`,
+  );
+}

package/src/models/handoff-token-response.ts

@@ -0,0 +1,49 @@
+/*
+ * 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";
+
+export const DevicePosition = {
+  Origin: "origin",
+  Joined: "joined",
+} as const;
+export type DevicePosition = OpenEnum<typeof DevicePosition>;
+
+export type HandoffTokenResponse = {
+  instanceUrl: string;
+  devicePosition: DevicePosition;
+  expiresIn: number;
+};
+
+/** @internal */
+export const DevicePosition$inboundSchema: z.ZodMiniType<
+  DevicePosition,
+  unknown
+> = openEnums.inboundSchema(DevicePosition);
+
+/** @internal */
+export const HandoffTokenResponse$inboundSchema: z.ZodMiniType<
+  HandoffTokenResponse,
+  unknown
+> = z.object({
+  instanceUrl: types.string(),
+  devicePosition: DevicePosition$inboundSchema,
+  expiresIn: types.number(),
+});
+
+export function handoffTokenResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<HandoffTokenResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HandoffTokenResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HandoffTokenResponse' from JSON`,
+  );
+}

package/src/models/index.ts

@@ -3,5 +3,35 @@
  */
 
 export * from "./client-credentials-grant-request.js";
+export * from "./create-sandbox-scenario-request.js";
+export * from "./delete-response.js";
+export * from "./device-connect-response.js";
+export * from "./device-refresh-response.js";
+export * from "./device-start-response.js";
+export * from "./device-validate-response.js";
+export * from "./gbg-error.js";
+export * from "./handoff-token-response.js";
+export * from "./interaction-fetch-response.js";
+export * from "./interaction-submit-response.js";
+export * from "./journey-start-response.js";
+export * from "./loqate-retrieve-response.js";
+export * from "./loqate-search-response.js";
 export * from "./password-grant-request.js";
+export * from "./sandbox-scenario-summary.js";
+export * from "./sandbox-scenario-written.js";
+export * from "./sandbox-scenario.js";
+export * from "./schema-fetch-response.js";
 export * from "./security.js";
+export * from "./slim-document.js";
+export * from "./slim-extraction.js";
+export * from "./slim-identity.js";
+export * from "./slim-interaction-fetch-response.js";
+export * from "./slim-journey.js";
+export * from "./slim-result.js";
+export * from "./slim-state-fetch-response.js";
+export * from "./slim-step.js";
+export * from "./slim-validation.js";
+export * from "./slim-verified-data.js";
+export * from "./state-fetch-response.js";
+export * from "./terminate-response.js";
+export * from "./update-sandbox-scenario-request.js";

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

@@ -0,0 +1,147 @@
+/*
+ * 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 * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type InteractionFetchResponseJourney = {
+  status: string;
+};
+
+export const InteractionFetchResponseCardinality = {
+  AtLeastOne: "at-least-one",
+} as const;
+export type InteractionFetchResponseCardinality = ClosedEnum<
+  typeof InteractionFetchResponseCardinality
+>;
+
+export type InteractionFetchResponseOutstandingGroup = {
+  elementId: string;
+  cardinality: InteractionFetchResponseCardinality;
+  refs: Array<string>;
+};
+
+export type InteractionFetchResponseJoinedDevice = {
+  connected: boolean;
+};
+
+export type InteractionFetchResponse = {
+  instanceId: string;
+  interactionId?: string | undefined;
+  journey: InteractionFetchResponseJourney;
+  interaction?: { [k: string]: any } | undefined;
+  context?: { [k: string]: any } | undefined;
+  instructions?: any | undefined;
+  outstanding?: any | undefined;
+  outstandingGroups?:
+    | Array<InteractionFetchResponseOutstandingGroup>
+    | undefined;
+  processing?: boolean | undefined;
+  result?: { [k: string]: any } | undefined;
+  joinedDevice?: InteractionFetchResponseJoinedDevice | undefined;
+};
+
+/** @internal */
+export const InteractionFetchResponseJourney$inboundSchema: z.ZodMiniType<
+  InteractionFetchResponseJourney,
+  unknown
+> = z.object({
+  status: types.string(),
+});
+
+export function interactionFetchResponseJourneyFromJSON(
+  jsonString: string,
+): SafeParseResult<InteractionFetchResponseJourney, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InteractionFetchResponseJourney$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InteractionFetchResponseJourney' from JSON`,
+  );
+}
+
+/** @internal */
+export const InteractionFetchResponseCardinality$inboundSchema: z.ZodMiniEnum<
+  typeof InteractionFetchResponseCardinality
+> = z.enum(InteractionFetchResponseCardinality);
+
+/** @internal */
+export const InteractionFetchResponseOutstandingGroup$inboundSchema:
+  z.ZodMiniType<InteractionFetchResponseOutstandingGroup, unknown> = z.object({
+    elementId: types.string(),
+    cardinality: InteractionFetchResponseCardinality$inboundSchema,
+    refs: z.array(types.string()),
+  });
+
+export function interactionFetchResponseOutstandingGroupFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  InteractionFetchResponseOutstandingGroup,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      InteractionFetchResponseOutstandingGroup$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'InteractionFetchResponseOutstandingGroup' from JSON`,
+  );
+}
+
+/** @internal */
+export const InteractionFetchResponseJoinedDevice$inboundSchema: z.ZodMiniType<
+  InteractionFetchResponseJoinedDevice,
+  unknown
+> = z.object({
+  connected: types.boolean(),
+});
+
+export function interactionFetchResponseJoinedDeviceFromJSON(
+  jsonString: string,
+): SafeParseResult<InteractionFetchResponseJoinedDevice, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      InteractionFetchResponseJoinedDevice$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InteractionFetchResponseJoinedDevice' from JSON`,
+  );
+}
+
+/** @internal */
+export const InteractionFetchResponse$inboundSchema: z.ZodMiniType<
+  InteractionFetchResponse,
+  unknown
+> = z.object({
+  instanceId: types.string(),
+  interactionId: types.optional(types.string()),
+  journey: z.lazy(() => InteractionFetchResponseJourney$inboundSchema),
+  interaction: types.optional(z.record(z.string(), z.any())),
+  context: types.optional(z.record(z.string(), z.any())),
+  instructions: types.optional(z.any()),
+  outstanding: types.optional(z.any()),
+  outstandingGroups: types.optional(
+    z.array(
+      z.lazy(() => InteractionFetchResponseOutstandingGroup$inboundSchema),
+    ),
+  ),
+  processing: types.optional(types.boolean()),
+  result: types.optional(z.record(z.string(), z.any())),
+  joinedDevice: types.optional(
+    z.lazy(() => InteractionFetchResponseJoinedDevice$inboundSchema),
+  ),
+});
+
+export function interactionFetchResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<InteractionFetchResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InteractionFetchResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InteractionFetchResponse' from JSON`,
+  );
+}

package/src/models/interaction-submit-response.ts

@@ -0,0 +1,43 @@
+/*
+ * 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 InteractionSubmitResponseStatus = {
+  Success: "success",
+} as const;
+export type InteractionSubmitResponseStatus = ClosedEnum<
+  typeof InteractionSubmitResponseStatus
+>;
+
+export type InteractionSubmitResponse = {
+  status: InteractionSubmitResponseStatus;
+};
+
+/** @internal */
+export const InteractionSubmitResponseStatus$inboundSchema: z.ZodMiniEnum<
+  typeof InteractionSubmitResponseStatus
+> = z.enum(InteractionSubmitResponseStatus);
+
+/** @internal */
+export const InteractionSubmitResponse$inboundSchema: z.ZodMiniType<
+  InteractionSubmitResponse,
+  unknown
+> = z.object({
+  status: InteractionSubmitResponseStatus$inboundSchema,
+});
+
+export function interactionSubmitResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<InteractionSubmitResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InteractionSubmitResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InteractionSubmitResponse' from JSON`,
+  );
+}

package/src/models/journey-start-response.ts

@@ -0,0 +1,64 @@
+/*
+ * 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 {
+  StateFetchResponse,
+  StateFetchResponse$inboundSchema,
+} from "./state-fetch-response.js";
+
+export const JourneyStartResponseStatus = {
+  Started: "started",
+  Completed: "completed",
+  Failed: "failed",
+  AwaitingInput: "awaiting-input",
+  Pending: "pending",
+} as const;
+export type JourneyStartResponseStatus = OpenEnum<
+  typeof JourneyStartResponseStatus
+>;
+
+export type JourneyStartResponse = {
+  instanceId: string;
+  instanceUrl?: string | undefined;
+  status: JourneyStartResponseStatus;
+  message?: string | undefined;
+  waitedSeconds?: number | undefined;
+  state?: StateFetchResponse | undefined;
+};
+
+/** @internal */
+export const JourneyStartResponseStatus$inboundSchema: z.ZodMiniType<
+  JourneyStartResponseStatus,
+  unknown
+> = openEnums.inboundSchema(JourneyStartResponseStatus);
+
+/** @internal */
+export const JourneyStartResponse$inboundSchema: z.ZodMiniType<
+  JourneyStartResponse,
+  unknown
+> = z.object({
+  instanceId: types.string(),
+  instanceUrl: types.optional(types.string()),
+  status: JourneyStartResponseStatus$inboundSchema,
+  message: types.optional(types.string()),
+  waitedSeconds: types.optional(types.number()),
+  state: types.optional(StateFetchResponse$inboundSchema),
+});
+
+export function journeyStartResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<JourneyStartResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => JourneyStartResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'JourneyStartResponse' from JSON`,
+  );
+}

package/src/models/loqate-retrieve-response.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";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type LoqateRetrieveResponse = {
+  items: Array<{ [k: string]: any }>;
+};
+
+/** @internal */
+export const LoqateRetrieveResponse$inboundSchema: z.ZodMiniType<
+  LoqateRetrieveResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    Items: z.array(z.record(z.string(), z.any())),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "Items": "items",
+    });
+  }),
+);
+
+export function loqateRetrieveResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<LoqateRetrieveResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LoqateRetrieveResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LoqateRetrieveResponse' from JSON`,
+  );
+}

package/src/models/loqate-search-response.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";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type LoqateSearchResponse = {
+  items: Array<{ [k: string]: any }>;
+};
+
+/** @internal */
+export const LoqateSearchResponse$inboundSchema: z.ZodMiniType<
+  LoqateSearchResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    Items: z.array(z.record(z.string(), z.any())),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "Items": "items",
+    });
+  }),
+);
+
+export function loqateSearchResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<LoqateSearchResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LoqateSearchResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LoqateSearchResponse' from JSON`,
+  );
+}