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

package/src/models/operations/terminate-journey.ts

@@ -0,0 +1,41 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type TerminateJourneyRequest = {
+  /**
+   * Journey Instance Id, a unique identifier for a started journey instance.
+   */
+  instanceId: string;
+  reason?: string | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export type TerminateJourneyRequest$Outbound = {
+  instanceId: string;
+  reason?: string | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const TerminateJourneyRequest$outboundSchema: z.ZodMiniType<
+  TerminateJourneyRequest$Outbound,
+  TerminateJourneyRequest
+> = z.catchall(
+  z.object({
+    instanceId: z.string(),
+    reason: z.optional(z.string()),
+  }),
+  z.any(),
+);
+
+export function terminateJourneyRequestToJSON(
+  terminateJourneyRequest: TerminateJourneyRequest,
+): string {
+  return JSON.stringify(
+    TerminateJourneyRequest$outboundSchema.parse(terminateJourneyRequest),
+  );
+}

package/src/models/operations/upload-interaction-asset.ts

@@ -0,0 +1,75 @@
+/*
+ * 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 UploadInteractionAssetSecurity = {
+  customerAccess?: string | undefined;
+  interactionAccess?: string | undefined;
+};
+
+/**
+ * Asset stored; returns the gofs key to reference in the subsequent submit
+ */
+export type UploadInteractionAssetResponse = {
+  domainElementId: string;
+  gofsKey: string;
+};
+
+/** @internal */
+export type UploadInteractionAssetSecurity$Outbound = {
+  CustomerAccess?: string | undefined;
+  InteractionAccess?: string | undefined;
+};
+
+/** @internal */
+export const UploadInteractionAssetSecurity$outboundSchema: z.ZodMiniType<
+  UploadInteractionAssetSecurity$Outbound,
+  UploadInteractionAssetSecurity
+> = z.pipe(
+  z.object({
+    customerAccess: z.optional(z.string()),
+    interactionAccess: z.optional(z.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      customerAccess: "CustomerAccess",
+      interactionAccess: "InteractionAccess",
+    });
+  }),
+);
+
+export function uploadInteractionAssetSecurityToJSON(
+  uploadInteractionAssetSecurity: UploadInteractionAssetSecurity,
+): string {
+  return JSON.stringify(
+    UploadInteractionAssetSecurity$outboundSchema.parse(
+      uploadInteractionAssetSecurity,
+    ),
+  );
+}
+
+/** @internal */
+export const UploadInteractionAssetResponse$inboundSchema: z.ZodMiniType<
+  UploadInteractionAssetResponse,
+  unknown
+> = z.object({
+  domainElementId: types.string(),
+  gofsKey: types.string(),
+});
+
+export function uploadInteractionAssetResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadInteractionAssetResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadInteractionAssetResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadInteractionAssetResponse' from JSON`,
+  );
+}

package/src/models/sandbox-scenario-summary.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";
+
+export const SandboxScenarioSummaryTier = {
+  Platform: "platform",
+  Org: "org",
+} as const;
+export type SandboxScenarioSummaryTier = OpenEnum<
+  typeof SandboxScenarioSummaryTier
+>;
+
+export type SandboxScenarioSummary = {
+  name: string;
+  tier: SandboxScenarioSummaryTier;
+  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 SandboxScenarioSummaryTier$inboundSchema: z.ZodMiniType<
+  SandboxScenarioSummaryTier,
+  unknown
+> = openEnums.inboundSchema(SandboxScenarioSummaryTier);
+
+/** @internal */
+export const SandboxScenarioSummary$inboundSchema: z.ZodMiniType<
+  SandboxScenarioSummary,
+  unknown
+> = z.object({
+  name: types.string(),
+  tier: SandboxScenarioSummaryTier$inboundSchema,
+  editable: types.boolean(),
+  description: types.optional(types.string()),
+  lastModifiedTime: types.optional(types.date()),
+  lastModifiedBy: types.optional(types.string()),
+});
+
+export function sandboxScenarioSummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<SandboxScenarioSummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SandboxScenarioSummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SandboxScenarioSummary' from JSON`,
+  );
+}

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

@@ -0,0 +1,48 @@
+/*
+ * 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 SandboxScenarioWrittenTier = {
+  Org: "org",
+} as const;
+export type SandboxScenarioWrittenTier = ClosedEnum<
+  typeof SandboxScenarioWrittenTier
+>;
+
+export type SandboxScenarioWritten = {
+  name: string;
+  journeyId: string;
+  tier: SandboxScenarioWrittenTier;
+};
+
+/** @internal */
+export const SandboxScenarioWrittenTier$inboundSchema: z.ZodMiniEnum<
+  typeof SandboxScenarioWrittenTier
+> = z.enum(SandboxScenarioWrittenTier);
+
+/** @internal */
+export const SandboxScenarioWritten$inboundSchema: z.ZodMiniType<
+  SandboxScenarioWritten,
+  unknown
+> = z.object({
+  name: types.string(),
+  journeyId: types.string(),
+  tier: SandboxScenarioWrittenTier$inboundSchema,
+});
+
+export function sandboxScenarioWrittenFromJSON(
+  jsonString: string,
+): SafeParseResult<SandboxScenarioWritten, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SandboxScenarioWritten$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SandboxScenarioWritten' from JSON`,
+  );
+}

package/src/models/sandbox-scenario.ts

@@ -0,0 +1,61 @@
+/*
+ * 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 SandboxScenarioTier = {
+  Platform: "platform",
+  Org: "org",
+} as const;
+export type SandboxScenarioTier = OpenEnum<typeof SandboxScenarioTier>;
+
+export type SandboxScenario = {
+  name: string;
+  journeyId: string;
+  tier: SandboxScenarioTier;
+  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 SandboxScenarioTier$inboundSchema: z.ZodMiniType<
+  SandboxScenarioTier,
+  unknown
+> = openEnums.inboundSchema(SandboxScenarioTier);
+
+/** @internal */
+export const SandboxScenario$inboundSchema: z.ZodMiniType<
+  SandboxScenario,
+  unknown
+> = z.object({
+  name: types.string(),
+  journeyId: types.string(),
+  tier: SandboxScenarioTier$inboundSchema,
+  data: z.record(z.string(), z.any()),
+  lastModifiedTime: types.optional(types.date()),
+  lastModifiedBy: types.optional(types.string()),
+});
+
+export function sandboxScenarioFromJSON(
+  jsonString: string,
+): SafeParseResult<SandboxScenario, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SandboxScenario$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SandboxScenario' from JSON`,
+  );
+}

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

@@ -0,0 +1,58 @@
+/*
+ * 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 Schema = {
+  interactionId: string;
+  instruction?: string | undefined;
+  schema: { [k: string]: any };
+};
+
+export type SchemaFetchResponse = {
+  deliveryId: string;
+  resolvedVersion: string;
+  schemas: Array<Schema>;
+};
+
+/** @internal */
+export const Schema$inboundSchema: z.ZodMiniType<Schema, unknown> = z.object({
+  interactionId: types.string(),
+  instruction: types.optional(types.string()),
+  schema: z.record(z.string(), z.any()),
+});
+
+export function schemaFromJSON(
+  jsonString: string,
+): SafeParseResult<Schema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Schema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Schema' from JSON`,
+  );
+}
+
+/** @internal */
+export const SchemaFetchResponse$inboundSchema: z.ZodMiniType<
+  SchemaFetchResponse,
+  unknown
+> = z.object({
+  deliveryId: types.string(),
+  resolvedVersion: types.string(),
+  schemas: z.array(z.lazy(() => Schema$inboundSchema)),
+});
+
+export function schemaFetchResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SchemaFetchResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SchemaFetchResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SchemaFetchResponse' from JSON`,
+  );
+}

package/src/models/slim-document.ts

@@ -0,0 +1,135 @@
+/*
+ * 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 {
+  SlimExtraction,
+  SlimExtraction$inboundSchema,
+} from "./slim-extraction.js";
+import {
+  SlimValidation,
+  SlimValidation$inboundSchema,
+} from "./slim-validation.js";
+
+export type Side = {
+  side: string;
+  id: string;
+  documentQuality: string;
+  documentQualityScore: number;
+};
+
+export type Classification = {
+  ids?: Array<string> | undefined;
+  category?: string | undefined;
+  type?: string | undefined;
+  subtype?: string | undefined;
+  isDoubleSided?: boolean | undefined;
+  hasNFC?: boolean | undefined;
+  year?: string | undefined;
+  countryCode?: string | undefined;
+  countryName?: string | undefined;
+  stateCode?: string | undefined;
+  stateName?: string | undefined;
+  sides?: Array<Side> | undefined;
+};
+
+export type SlimDocument = {
+  type?: string | undefined;
+  category?: string | undefined;
+  subType?: string | undefined;
+  format?: string | undefined;
+  number?: string | undefined;
+  /**
+   * Specified in year, month and day separated by -.  For example 2017-1-1 or 2017-01-01 which conforms to ISO 8601
+   */
+  issueDate?: string | undefined;
+  /**
+   * Specified in year, month and day separated by -.  For example 2017-1-1 or 2017-01-01 which conforms to ISO 8601
+   */
+  expiryDate?: string | undefined;
+  /**
+   * Country the address is in. It must be a valid ISO2 or ISO3 country code
+   */
+  country?: string | undefined;
+  classification?: Classification | undefined;
+  extraction?: SlimExtraction | undefined;
+  validation?: SlimValidation | undefined;
+};
+
+/** @internal */
+export const Side$inboundSchema: z.ZodMiniType<Side, unknown> = z.object({
+  side: types.string(),
+  id: types.string(),
+  documentQuality: types.string(),
+  documentQualityScore: types.number(),
+});
+
+export function sideFromJSON(
+  jsonString: string,
+): SafeParseResult<Side, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Side$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Side' from JSON`,
+  );
+}
+
+/** @internal */
+export const Classification$inboundSchema: z.ZodMiniType<
+  Classification,
+  unknown
+> = z.object({
+  ids: types.optional(z.array(types.string())),
+  category: types.optional(types.string()),
+  type: types.optional(types.string()),
+  subtype: types.optional(types.string()),
+  isDoubleSided: types.optional(types.boolean()),
+  hasNFC: types.optional(types.boolean()),
+  year: types.optional(types.string()),
+  countryCode: types.optional(types.string()),
+  countryName: types.optional(types.string()),
+  stateCode: types.optional(types.string()),
+  stateName: types.optional(types.string()),
+  sides: types.optional(z.array(z.lazy(() => Side$inboundSchema))),
+});
+
+export function classificationFromJSON(
+  jsonString: string,
+): SafeParseResult<Classification, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Classification$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Classification' from JSON`,
+  );
+}
+
+/** @internal */
+export const SlimDocument$inboundSchema: z.ZodMiniType<SlimDocument, unknown> =
+  z.object({
+    type: types.optional(types.string()),
+    category: types.optional(types.string()),
+    subType: types.optional(types.string()),
+    format: types.optional(types.string()),
+    number: types.optional(types.string()),
+    issueDate: types.optional(types.string()),
+    expiryDate: types.optional(types.string()),
+    country: types.optional(types.string()),
+    classification: types.optional(z.lazy(() => Classification$inboundSchema)),
+    extraction: types.optional(SlimExtraction$inboundSchema),
+    validation: types.optional(SlimValidation$inboundSchema),
+  });
+
+export function slimDocumentFromJSON(
+  jsonString: string,
+): SafeParseResult<SlimDocument, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SlimDocument$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SlimDocument' from JSON`,
+  );
+}