@factify/sdk 1.1.0-rc.7 → 1.1.0-rc.9

package/src/models/components/qcrv1alphablockspacing.ts

@@ -0,0 +1,56 @@
+/*
+ * 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/sdkvalidationerror.js";
+import {
+  QcrV1alphaLineSpacingValue,
+  QcrV1alphaLineSpacingValue$inboundSchema,
+} from "./qcrv1alphalinespacingvalue.js";
+
+export type QcrV1alphaBlockSpacing = {
+  afterMm?: number | undefined;
+  beforeMm?: number | undefined;
+  /**
+   * Line spacing as mode + optional explicit value.
+   *
+   * @remarks
+   *  Using a message instead of a bare enum avoids a future wire break when
+   *  exact/at-least modes are added (they need a companion float value).
+   */
+  lineSpacing?: QcrV1alphaLineSpacingValue | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaBlockSpacing$inboundSchema: z.ZodMiniType<
+  QcrV1alphaBlockSpacing,
+  unknown
+> = z.pipe(
+  z.object({
+    after_mm: types.optional(types.number()),
+    before_mm: types.optional(types.number()),
+    line_spacing: types.optional(QcrV1alphaLineSpacingValue$inboundSchema),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "after_mm": "afterMm",
+      "before_mm": "beforeMm",
+      "line_spacing": "lineSpacing",
+    });
+  }),
+);
+
+export function qcrV1alphaBlockSpacingFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaBlockSpacing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaBlockSpacing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaBlockSpacing' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphaboundingbox.ts

@@ -0,0 +1,46 @@
+/*
+ * 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/sdkvalidationerror.js";
+
+/**
+ * Normalized bounding box relative to the page (0.0–1.0).
+ *
+ * @remarks
+ *  Origin is top-left: (0,0) is the top-left corner of the page,
+ *  x increases rightward, y increases downward.
+ *  Extraction pipelines must flip the y-axis for bottom-left origin formats (PDF).
+ *  To get absolute coordinates, multiply by the page's PhysicalDimensions.
+ */
+export type QcrV1alphaBoundingBox = {
+  height?: number | undefined;
+  width?: number | undefined;
+  x?: number | undefined;
+  y?: number | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaBoundingBox$inboundSchema: z.ZodMiniType<
+  QcrV1alphaBoundingBox,
+  unknown
+> = z.object({
+  height: types.optional(types.number()),
+  width: types.optional(types.number()),
+  x: types.optional(types.number()),
+  y: types.optional(types.number()),
+});
+
+export function qcrV1alphaBoundingBoxFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaBoundingBox, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaBoundingBox$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaBoundingBox' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphacodeblockdata.ts

@@ -0,0 +1,33 @@
+/*
+ * 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/sdkvalidationerror.js";
+
+export type QcrV1alphaCodeBlockData = {
+  code?: string | undefined;
+  language?: string | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaCodeBlockData$inboundSchema: z.ZodMiniType<
+  QcrV1alphaCodeBlockData,
+  unknown
+> = z.object({
+  code: types.optional(types.string()),
+  language: types.optional(types.string()),
+});
+
+export function qcrV1alphaCodeBlockDataFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaCodeBlockData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaCodeBlockData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaCodeBlockData' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphadatasource.ts

@@ -0,0 +1,108 @@
+/*
+ * 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 { smartUnion } from "../../types/smartUnion.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  QcrV1alphaMimeType,
+  QcrV1alphaMimeType$inboundSchema,
+} from "./qcrv1alphamimetype.js";
+
+export type StorageRef = {
+  /**
+   * S3 key, CDN URL, or other stable reference
+   */
+  storageRef: string;
+  mimeType?: QcrV1alphaMimeType | undefined;
+};
+
+export type InlineData = {
+  /**
+   * raw bytes for small/embedded content
+   */
+  inlineData: string;
+  mimeType?: QcrV1alphaMimeType | undefined;
+};
+
+/**
+ * DataSource represents a media payload — either a stable external reference
+ *
+ * @remarks
+ *  or inline bytes — paired with its MIME type.
+ */
+export type QcrV1alphaDataSource = InlineData | StorageRef;
+
+/** @internal */
+export const StorageRef$inboundSchema: z.ZodMiniType<StorageRef, unknown> = z
+  .pipe(
+    z.object({
+      storage_ref: types.string(),
+      mime_type: types.optional(QcrV1alphaMimeType$inboundSchema),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "storage_ref": "storageRef",
+        "mime_type": "mimeType",
+      });
+    }),
+  );
+
+export function storageRefFromJSON(
+  jsonString: string,
+): SafeParseResult<StorageRef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StorageRef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StorageRef' from JSON`,
+  );
+}
+
+/** @internal */
+export const InlineData$inboundSchema: z.ZodMiniType<InlineData, unknown> = z
+  .pipe(
+    z.object({
+      inline_data: types.string(),
+      mime_type: types.optional(QcrV1alphaMimeType$inboundSchema),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "inline_data": "inlineData",
+        "mime_type": "mimeType",
+      });
+    }),
+  );
+
+export function inlineDataFromJSON(
+  jsonString: string,
+): SafeParseResult<InlineData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InlineData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InlineData' from JSON`,
+  );
+}
+
+/** @internal */
+export const QcrV1alphaDataSource$inboundSchema: z.ZodMiniType<
+  QcrV1alphaDataSource,
+  unknown
+> = smartUnion([
+  z.lazy(() => InlineData$inboundSchema),
+  z.lazy(() => StorageRef$inboundSchema),
+]);
+
+export function qcrV1alphaDataSourceFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaDataSource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaDataSource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaDataSource' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphadirection.ts

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+/**
+ * Text direction / reading order.
+ */
+export const QcrV1alphaDirection = {
+  DirectionUnspecified: "DIRECTION_UNSPECIFIED",
+  DirectionLtr: "DIRECTION_LTR",
+  DirectionRtl: "DIRECTION_RTL",
+} as const;
+/**
+ * Text direction / reading order.
+ */
+export type QcrV1alphaDirection = OpenEnum<typeof QcrV1alphaDirection>;
+
+/** @internal */
+export const QcrV1alphaDirection$inboundSchema: z.ZodMiniType<
+  QcrV1alphaDirection,
+  unknown
+> = openEnums.inboundSchema(QcrV1alphaDirection);

package/src/models/components/qcrv1alphadocumentlayout.ts

@@ -0,0 +1,113 @@
+/*
+ * 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/sdkvalidationerror.js";
+import {
+  QcrV1alphaLayoutBinding,
+  QcrV1alphaLayoutBinding$inboundSchema,
+} from "./qcrv1alphalayoutbinding.js";
+import {
+  QcrV1alphaLayoutDefaults,
+  QcrV1alphaLayoutDefaults$inboundSchema,
+} from "./qcrv1alphalayoutdefaults.js";
+import {
+  QcrV1alphaPageGeometry,
+  QcrV1alphaPageGeometry$inboundSchema,
+} from "./qcrv1alphapagegeometry.js";
+import {
+  QcrV1alphaSourceReference,
+  QcrV1alphaSourceReference$inboundSchema,
+} from "./qcrv1alphasourcereference.js";
+
+/**
+ * Top-level layout structure, joined to a DocumentRecord by record_id.
+ *
+ * @remarks
+ *  Used with the Block-based record representation (DocumentRecord.blocks).
+ */
+export type QcrV1alphaDocumentLayout = {
+  /**
+   * sparse element → layout entries
+   */
+  bindings?: Array<QcrV1alphaLayoutBinding> | undefined;
+  /**
+   * Document-wide layout defaults.
+   */
+  defaults?: QcrV1alphaLayoutDefaults | undefined;
+  extractedAt?: Date | undefined;
+  /**
+   * page-level geometry (all pages)
+   */
+  pages?: Array<QcrV1alphaPageGeometry> | undefined;
+  /**
+   * references DocumentRecord.id
+   */
+  recordId?: string | undefined;
+  /**
+   * SourceReference links a record back to the source it was extracted from.
+   *
+   * @remarks
+   *
+   *  Three typed fields identify WHAT, WHERE, and WHEN. Everything else —
+   *  format, content hash, storage location, checksums, external URLs — goes
+   *  in the attributes bag, because the relevant metadata varies by source type.
+   *
+   *  Examples by source type:
+   *
+   *    File upload:
+   *      source_id  = "intg_01j8k..."                    (upload channel instance)
+   *      remote_id  = "req_01h2xcejqtf2nbrexx3vqjhp41"   (upload request ID)
+   *      attributes = {format: "pdf", location: "uploads/.../original.pdf",
+   *                    content_hash: "a1b2c3...", storage_etag: "\"abc\""}
+   *
+   *    Gmail integration:
+   *      source_id  = "intg_01k9m..."                    (Gmail connector instance)
+   *      remote_id  = "18abc123def"                       (Gmail message ID)
+   *      attributes = {format: "eml", thread_id: "...",
+   *                    external_url: "https://mail.google.com/..."}
+   *
+   *    Confluence sync:
+   *      source_id  = "intg_01p3q..."                    (Confluence connector instance)
+   *      remote_id  = "12345678"                          (Confluence page ID)
+   *      attributes = {format: "html", space_key: "ENG",
+   *                    external_url: "https://acme.atlassian.net/wiki/..."}
+   */
+  source?: QcrV1alphaSourceReference | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaDocumentLayout$inboundSchema: z.ZodMiniType<
+  QcrV1alphaDocumentLayout,
+  unknown
+> = z.pipe(
+  z.object({
+    bindings: types.optional(z.array(QcrV1alphaLayoutBinding$inboundSchema)),
+    defaults: types.optional(QcrV1alphaLayoutDefaults$inboundSchema),
+    extracted_at: types.optional(types.date()),
+    pages: types.optional(z.array(QcrV1alphaPageGeometry$inboundSchema)),
+    record_id: types.optional(types.string()),
+    source: types.optional(QcrV1alphaSourceReference$inboundSchema),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "extracted_at": "extractedAt",
+      "record_id": "recordId",
+    });
+  }),
+);
+
+export function qcrV1alphaDocumentLayoutFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaDocumentLayout, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaDocumentLayout$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaDocumentLayout' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphadocumentmetadata.ts

@@ -0,0 +1,60 @@
+/*
+ * 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/sdkvalidationerror.js";
+import { Value, Value$inboundSchema } from "./value.js";
+
+export type QcrV1alphaDocumentMetadata = {
+  /**
+   * `Struct` represents a structured data value, consisting of fields
+   *
+   * @remarks
+   *  which map to dynamically typed values. In some languages, `Struct`
+   *  might be supported by a native representation. For example, in
+   *  scripting languages like JS a struct is represented as an
+   *  object. The details of that representation are described together
+   *  with the proto support for the language.
+   *
+   *  The JSON representation for `Struct` is JSON object.
+   */
+  attributes?: { [k: string]: Value | null } | undefined;
+  extractedAt?: Date | undefined;
+  language?: string | undefined;
+  title?: string | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaDocumentMetadata$inboundSchema: z.ZodMiniType<
+  QcrV1alphaDocumentMetadata,
+  unknown
+> = z.pipe(
+  z.object({
+    attributes: types.optional(
+      z.record(z.string(), types.nullable(Value$inboundSchema)),
+    ),
+    extracted_at: types.optional(types.date()),
+    language: types.optional(types.string()),
+    title: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "extracted_at": "extractedAt",
+    });
+  }),
+);
+
+export function qcrV1alphaDocumentMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaDocumentMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaDocumentMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaDocumentMetadata' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphadocumentrecord.ts

@@ -0,0 +1,99 @@
+/*
+ * 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/sdkvalidationerror.js";
+import {
+  QcrV1alphaBlock,
+  QcrV1alphaBlock$inboundSchema,
+} from "./qcrv1alphablock.js";
+import {
+  QcrV1alphaDocumentMetadata,
+  QcrV1alphaDocumentMetadata$inboundSchema,
+} from "./qcrv1alphadocumentmetadata.js";
+import {
+  QcrV1alphaSourceReference,
+  QcrV1alphaSourceReference$inboundSchema,
+} from "./qcrv1alphasourcereference.js";
+
+/**
+ * DocumentRecord is the QCR representation of an ingested document.
+ *
+ * @remarks
+ *  Immutable once extracted. Source-format-agnostic.
+ *
+ *  Structure is a flat sequence of blocks. Sections provide optional grouping
+ *  and can nest, but block-level elements (paragraphs, tables, etc.) are leaves
+ *  — they do not contain other blocks. This constrains nesting to only what is
+ *  semantically valid and gives every element a natural positional address.
+ *
+ *  Addressing convention: every element is addressable by its index path through
+ *  the typed containment hierarchy. Examples:
+ *    blocks[2]                        → third block
+ *    blocks[2].section.blocks[0]      → first block inside a section
+ *    blocks[4].table.rows[1].cells[0] → second row, first cell of a table
+ *    blocks[3].list.items[2]          → third item of a list
+ *
+ *  These addresses are deterministic for a given record and are used by
+ *  DocumentLayout to join layout data to semantic content.
+ */
+export type QcrV1alphaDocumentRecord = {
+  blocks?: Array<QcrV1alphaBlock> | undefined;
+  id?: string | undefined;
+  metadata?: QcrV1alphaDocumentMetadata | undefined;
+  /**
+   * SourceReference links a record back to the source it was extracted from.
+   *
+   * @remarks
+   *
+   *  Three typed fields identify WHAT, WHERE, and WHEN. Everything else —
+   *  format, content hash, storage location, checksums, external URLs — goes
+   *  in the attributes bag, because the relevant metadata varies by source type.
+   *
+   *  Examples by source type:
+   *
+   *    File upload:
+   *      source_id  = "intg_01j8k..."                    (upload channel instance)
+   *      remote_id  = "req_01h2xcejqtf2nbrexx3vqjhp41"   (upload request ID)
+   *      attributes = {format: "pdf", location: "uploads/.../original.pdf",
+   *                    content_hash: "a1b2c3...", storage_etag: "\"abc\""}
+   *
+   *    Gmail integration:
+   *      source_id  = "intg_01k9m..."                    (Gmail connector instance)
+   *      remote_id  = "18abc123def"                       (Gmail message ID)
+   *      attributes = {format: "eml", thread_id: "...",
+   *                    external_url: "https://mail.google.com/..."}
+   *
+   *    Confluence sync:
+   *      source_id  = "intg_01p3q..."                    (Confluence connector instance)
+   *      remote_id  = "12345678"                          (Confluence page ID)
+   *      attributes = {format: "html", space_key: "ENG",
+   *                    external_url: "https://acme.atlassian.net/wiki/..."}
+   */
+  source?: QcrV1alphaSourceReference | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaDocumentRecord$inboundSchema: z.ZodMiniType<
+  QcrV1alphaDocumentRecord,
+  unknown
+> = z.object({
+  blocks: types.optional(z.array(QcrV1alphaBlock$inboundSchema)),
+  id: types.optional(types.string()),
+  metadata: types.optional(QcrV1alphaDocumentMetadata$inboundSchema),
+  source: types.optional(QcrV1alphaSourceReference$inboundSchema),
+});
+
+export function qcrV1alphaDocumentRecordFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaDocumentRecord, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaDocumentRecord$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaDocumentRecord' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphafootnotedata.ts

@@ -0,0 +1,33 @@
+/*
+ * 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/sdkvalidationerror.js";
+
+export type QcrV1alphaFootnoteData = {
+  label?: string | undefined;
+  text?: string | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaFootnoteData$inboundSchema: z.ZodMiniType<
+  QcrV1alphaFootnoteData,
+  unknown
+> = z.object({
+  label: types.optional(types.string()),
+  text: types.optional(types.string()),
+});
+
+export function qcrV1alphaFootnoteDataFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaFootnoteData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaFootnoteData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaFootnoteData' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphaheadingdata.ts

@@ -0,0 +1,33 @@
+/*
+ * 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/sdkvalidationerror.js";
+
+export type QcrV1alphaHeadingData = {
+  level?: number | undefined;
+  text?: string | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaHeadingData$inboundSchema: z.ZodMiniType<
+  QcrV1alphaHeadingData,
+  unknown
+> = z.object({
+  level: types.optional(types.number()),
+  text: types.optional(types.string()),
+});
+
+export function qcrV1alphaHeadingDataFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaHeadingData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaHeadingData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaHeadingData' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphaindentation.ts

@@ -0,0 +1,48 @@
+/*
+ * 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/sdkvalidationerror.js";
+
+export type QcrV1alphaIndentation = {
+  /**
+   * positive = indent, negative = hanging
+   */
+  firstLineMm?: number | undefined;
+  leftMm?: number | undefined;
+  rightMm?: number | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaIndentation$inboundSchema: z.ZodMiniType<
+  QcrV1alphaIndentation,
+  unknown
+> = z.pipe(
+  z.object({
+    first_line_mm: types.optional(types.number()),
+    left_mm: types.optional(types.number()),
+    right_mm: types.optional(types.number()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "first_line_mm": "firstLineMm",
+      "left_mm": "leftMm",
+      "right_mm": "rightMm",
+    });
+  }),
+);
+
+export function qcrV1alphaIndentationFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaIndentation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaIndentation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaIndentation' from JSON`,
+  );
+}