@factify/sdk 1.1.0-rc.11 → 1.1.0-rc.13

package/src/models/components/getrecordresponse.ts

@@ -7,68 +7,90 @@ 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 {
-  QcrV1alphaDocumentLayout,
-  QcrV1alphaDocumentLayout$inboundSchema,
-} from "./qcrv1alphadocumentlayout.js";
+  DocumentBundle,
+  DocumentBundle$inboundSchema,
+} from "./documentbundle.js";
 import {
-  QcrV1alphaDocumentRecord,
-  QcrV1alphaDocumentRecord$inboundSchema,
-} from "./qcrv1alphadocumentrecord.js";
+  SpreadsheetBundle,
+  SpreadsheetBundle$inboundSchema,
+} from "./spreadsheetbundle.js";
 
-/**
- * GetRecordResponse contains the processed document content and layout.
- */
-export type GetRecordResponse = {
+export type Spreadsheet = {
   /**
-   * 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.
+   * SpreadsheetBundle groups a spreadsheet record with its optional grid layout.
    */
-  document?: QcrV1alphaDocumentRecord | undefined;
+  spreadsheet: SpreadsheetBundle;
   /**
    * Unique record ID (UUID format).
    */
   id?: string | undefined;
   /**
-   * Top-level layout structure, joined to a DocumentRecord by record_id.
-   *
-   * @remarks
-   *  Used with the Block-based record representation (DocumentRecord.blocks).
+   * Source format of the original upload (e.g., pdf, docx, xlsx, csv).
+   */
+  sourceFormat?: string | undefined;
+};
+
+export type GetRecordResponseDocument = {
+  /**
+   * DocumentBundle groups a document record with its optional spatial layout.
+   */
+  document: DocumentBundle;
+  /**
+   * Unique record ID (UUID format).
    */
-  layout?: QcrV1alphaDocumentLayout | undefined;
+  id?: string | undefined;
   /**
-   * Source format of the original upload (e.g., pdf, docx, xlsx).
+   * Source format of the original upload (e.g., pdf, docx, xlsx, csv).
    */
   sourceFormat?: string | undefined;
 };
 
+/**
+ * GetRecordResponse contains the processed content and layout for a version.
+ *
+ * @remarks
+ *  The content oneof is populated based on source_format:
+ *    - document formats (pdf, docx, markdown): document field
+ *    - spreadsheet formats (xlsx, csv):        spreadsheet field
+ */
+export type GetRecordResponse = GetRecordResponseDocument | Spreadsheet;
+
 /** @internal */
-export const GetRecordResponse$inboundSchema: z.ZodMiniType<
-  GetRecordResponse,
+export const Spreadsheet$inboundSchema: z.ZodMiniType<Spreadsheet, unknown> = z
+  .pipe(
+    z.object({
+      spreadsheet: SpreadsheetBundle$inboundSchema,
+      id: types.optional(types.string()),
+      source_format: types.optional(types.string()),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "source_format": "sourceFormat",
+      });
+    }),
+  );
+
+export function spreadsheetFromJSON(
+  jsonString: string,
+): SafeParseResult<Spreadsheet, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Spreadsheet$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Spreadsheet' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetRecordResponseDocument$inboundSchema: z.ZodMiniType<
+  GetRecordResponseDocument,
   unknown
 > = z.pipe(
   z.object({
-    document: types.optional(QcrV1alphaDocumentRecord$inboundSchema),
+    document: DocumentBundle$inboundSchema,
     id: types.optional(types.string()),
-    layout: types.optional(QcrV1alphaDocumentLayout$inboundSchema),
     source_format: types.optional(types.string()),
   }),
   z.transform((v) => {
@@ -78,6 +100,25 @@ export const GetRecordResponse$inboundSchema: z.ZodMiniType<
   }),
 );
 
+export function getRecordResponseDocumentFromJSON(
+  jsonString: string,
+): SafeParseResult<GetRecordResponseDocument, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetRecordResponseDocument$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetRecordResponseDocument' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetRecordResponse$inboundSchema: z.ZodMiniType<
+  GetRecordResponse,
+  unknown
+> = smartUnion([
+  z.lazy(() => GetRecordResponseDocument$inboundSchema),
+  z.lazy(() => Spreadsheet$inboundSchema),
+]);
+
 export function getRecordResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<GetRecordResponse, SDKValidationError> {

package/src/models/components/index.ts

@@ -25,6 +25,7 @@ export * from "./dailyusage.js";
 export * from "./deleteapikeyquotaresponse.js";
 export * from "./denyaccessrequestresponse.js";
 export * from "./document.js";
+export * from "./documentbundle.js";
 export * from "./documentownership.js";
 export * from "./documentpermissionset.js";
 export * from "./documentpolicy.js";
@@ -76,14 +77,26 @@ export * from "./qcrv1alphablock.js";
 export * from "./qcrv1alphablockpath.js";
 export * from "./qcrv1alphablockspacing.js";
 export * from "./qcrv1alphaboundingbox.js";
+export * from "./qcrv1alphacellalignment.js";
+export * from "./qcrv1alphacellerrortype.js";
+export * from "./qcrv1alphacelllayoutbinding.js";
+export * from "./qcrv1alphacelltype.js";
 export * from "./qcrv1alphacodeblockdata.js";
+export * from "./qcrv1alphacolumndef.js";
+export * from "./qcrv1alphacolumnformatbinding.js";
+export * from "./qcrv1alphacolumnlayout.js";
+export * from "./qcrv1alphadatacell.js";
+export * from "./qcrv1alphadatarow.js";
 export * from "./qcrv1alphadatasource.js";
+export * from "./qcrv1alphadatatable.js";
 export * from "./qcrv1alphadirection.js";
 export * from "./qcrv1alphadocumentlayout.js";
 export * from "./qcrv1alphadocumentmetadata.js";
 export * from "./qcrv1alphadocumentrecord.js";
 export * from "./qcrv1alphafootnotedata.js";
+export * from "./qcrv1alphafrozenpane.js";
 export * from "./qcrv1alphaheadingdata.js";
+export * from "./qcrv1alphahorizontalalignment.js";
 export * from "./qcrv1alphaindentation.js";
 export * from "./qcrv1alphainsets.js";
 export * from "./qcrv1alphalayoutbinding.js";
@@ -95,7 +108,10 @@ export * from "./qcrv1alphalistdata.js";
 export * from "./qcrv1alphalistdataitem.js";
 export * from "./qcrv1alphaliststyle.js";
 export * from "./qcrv1alphamargins.js";
+export * from "./qcrv1alphamergedregion.js";
 export * from "./qcrv1alphamimetype.js";
+export * from "./qcrv1alphanamedrange.js";
+export * from "./qcrv1alphanumberformatcategory.js";
 export * from "./qcrv1alphaorientation.js";
 export * from "./qcrv1alphapagegeometry.js";
 export * from "./qcrv1alphapagesize.js";
@@ -104,8 +120,17 @@ export * from "./qcrv1alphapathsegment.js";
 export * from "./qcrv1alphaphysicaldimensions.js";
 export * from "./qcrv1alphaquotedata.js";
 export * from "./qcrv1alpharasterimagedata.js";
+export * from "./qcrv1alpharowlayout.js";
 export * from "./qcrv1alphasectiondata.js";
+export * from "./qcrv1alphasheet.js";
+export * from "./qcrv1alphasheetchart.js";
+export * from "./qcrv1alphasheetimage.js";
+export * from "./qcrv1alphasheetlayout.js";
 export * from "./qcrv1alphasourcereference.js";
+export * from "./qcrv1alphaspreadsheetlayout.js";
+export * from "./qcrv1alphaspreadsheetlayoutdefaults.js";
+export * from "./qcrv1alphaspreadsheetmetadata.js";
+export * from "./qcrv1alphaspreadsheetrecord.js";
 export * from "./qcrv1alphatablecelllayout.js";
 export * from "./qcrv1alphatabledata.js";
 export * from "./qcrv1alphatabledatarow.js";
@@ -117,6 +142,7 @@ export * from "./qcrv1alphatextalignment.js";
 export * from "./qcrv1alphatextblocklayout.js";
 export * from "./qcrv1alphathematicbreakdata.js";
 export * from "./qcrv1alphavectorimagedata.js";
+export * from "./qcrv1alphaverticalalignment.js";
 export * from "./quotatier.js";
 export * from "./recipient.js";
 export * from "./recipientgrant.js";
@@ -130,6 +156,7 @@ export * from "./security.js";
 export * from "./setapikeyquotaresponse.js";
 export * from "./setgeneralaccessresponse.js";
 export * from "./sharelink.js";
+export * from "./spreadsheetbundle.js";
 export * from "./subject.js";
 export * from "./subjecttype.js";
 export * from "./timelineevent.js";

package/src/models/components/qcrv1alphacellalignment.ts

@@ -0,0 +1,110 @@
+/*
+ * 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 {
+  QcrV1alphaHorizontalAlignment,
+  QcrV1alphaHorizontalAlignment$inboundSchema,
+} from "./qcrv1alphahorizontalalignment.js";
+import {
+  QcrV1alphaVerticalAlignment,
+  QcrV1alphaVerticalAlignment$inboundSchema,
+} from "./qcrv1alphaverticalalignment.js";
+
+export type VerticalText = {
+  /**
+   * stacked vertical text
+   */
+  verticalText: boolean;
+  horizontal?: QcrV1alphaHorizontalAlignment | undefined;
+  vertical?: QcrV1alphaVerticalAlignment | undefined;
+};
+
+export type RotationDegrees = {
+  /**
+   * -90 to 90; positive = counter-clockwise
+   */
+  rotationDegrees: number;
+  horizontal?: QcrV1alphaHorizontalAlignment | undefined;
+  vertical?: QcrV1alphaVerticalAlignment | undefined;
+};
+
+export type QcrV1alphaCellAlignment = RotationDegrees | VerticalText;
+
+/** @internal */
+export const VerticalText$inboundSchema: z.ZodMiniType<VerticalText, unknown> =
+  z.pipe(
+    z.object({
+      vertical_text: types.boolean(),
+      horizontal: types.optional(QcrV1alphaHorizontalAlignment$inboundSchema),
+      vertical: types.optional(QcrV1alphaVerticalAlignment$inboundSchema),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "vertical_text": "verticalText",
+      });
+    }),
+  );
+
+export function verticalTextFromJSON(
+  jsonString: string,
+): SafeParseResult<VerticalText, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VerticalText$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VerticalText' from JSON`,
+  );
+}
+
+/** @internal */
+export const RotationDegrees$inboundSchema: z.ZodMiniType<
+  RotationDegrees,
+  unknown
+> = z.pipe(
+  z.object({
+    rotation_degrees: types.number(),
+    horizontal: types.optional(QcrV1alphaHorizontalAlignment$inboundSchema),
+    vertical: types.optional(QcrV1alphaVerticalAlignment$inboundSchema),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "rotation_degrees": "rotationDegrees",
+    });
+  }),
+);
+
+export function rotationDegreesFromJSON(
+  jsonString: string,
+): SafeParseResult<RotationDegrees, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RotationDegrees$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RotationDegrees' from JSON`,
+  );
+}
+
+/** @internal */
+export const QcrV1alphaCellAlignment$inboundSchema: z.ZodMiniType<
+  QcrV1alphaCellAlignment,
+  unknown
+> = smartUnion([
+  z.lazy(() => RotationDegrees$inboundSchema),
+  z.lazy(() => VerticalText$inboundSchema),
+]);
+
+export function qcrV1alphaCellAlignmentFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaCellAlignment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaCellAlignment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaCellAlignment' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphacellerrortype.ts

@@ -0,0 +1,28 @@
+/*
+ * 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";
+
+export const QcrV1alphaCellErrorType = {
+  CellErrorTypeUnspecified: "CELL_ERROR_TYPE_UNSPECIFIED",
+  CellErrorTypeNull: "CELL_ERROR_TYPE_NULL",
+  CellErrorTypeDivZero: "CELL_ERROR_TYPE_DIV_ZERO",
+  CellErrorTypeValue: "CELL_ERROR_TYPE_VALUE",
+  CellErrorTypeRef: "CELL_ERROR_TYPE_REF",
+  CellErrorTypeName: "CELL_ERROR_TYPE_NAME",
+  CellErrorTypeNum: "CELL_ERROR_TYPE_NUM",
+  CellErrorTypeNa: "CELL_ERROR_TYPE_NA",
+  CellErrorTypeGettingData: "CELL_ERROR_TYPE_GETTING_DATA",
+  CellErrorTypeSpill: "CELL_ERROR_TYPE_SPILL",
+  CellErrorTypeCalc: "CELL_ERROR_TYPE_CALC",
+} as const;
+export type QcrV1alphaCellErrorType = OpenEnum<typeof QcrV1alphaCellErrorType>;
+
+/** @internal */
+export const QcrV1alphaCellErrorType$inboundSchema: z.ZodMiniType<
+  QcrV1alphaCellErrorType,
+  unknown
+> = openEnums.inboundSchema(QcrV1alphaCellErrorType);

package/src/models/components/qcrv1alphacelllayoutbinding.ts

@@ -0,0 +1,49 @@
+/*
+ * 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 {
+  QcrV1alphaCellAlignment,
+  QcrV1alphaCellAlignment$inboundSchema,
+} from "./qcrv1alphacellalignment.js";
+
+export type QcrV1alphaCellLayoutBinding = {
+  alignment?: QcrV1alphaCellAlignment | undefined;
+  col?: number | undefined;
+  row?: number | undefined;
+  textWrap?: boolean | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaCellLayoutBinding$inboundSchema: z.ZodMiniType<
+  QcrV1alphaCellLayoutBinding,
+  unknown
+> = z.pipe(
+  z.object({
+    alignment: types.optional(QcrV1alphaCellAlignment$inboundSchema),
+    col: types.optional(types.number()),
+    row: types.optional(types.number()),
+    text_wrap: types.optional(types.boolean()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "text_wrap": "textWrap",
+    });
+  }),
+);
+
+export function qcrV1alphaCellLayoutBindingFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaCellLayoutBinding, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaCellLayoutBinding$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaCellLayoutBinding' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphacelltype.ts

@@ -0,0 +1,25 @@
+/*
+ * 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";
+
+export const QcrV1alphaCellType = {
+  CellTypeUnspecified: "CELL_TYPE_UNSPECIFIED",
+  CellTypeString: "CELL_TYPE_STRING",
+  CellTypeNumber: "CELL_TYPE_NUMBER",
+  CellTypeBoolean: "CELL_TYPE_BOOLEAN",
+  CellTypeDate: "CELL_TYPE_DATE",
+  CellTypeError: "CELL_TYPE_ERROR",
+  CellTypeTime: "CELL_TYPE_TIME",
+  CellTypeDateTime: "CELL_TYPE_DATE_TIME",
+} as const;
+export type QcrV1alphaCellType = OpenEnum<typeof QcrV1alphaCellType>;
+
+/** @internal */
+export const QcrV1alphaCellType$inboundSchema: z.ZodMiniType<
+  QcrV1alphaCellType,
+  unknown
+> = openEnums.inboundSchema(QcrV1alphaCellType);

package/src/models/components/qcrv1alphacolumndef.ts

@@ -0,0 +1,76 @@
+/*
+ * 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 {
+  QcrV1alphaCellType,
+  QcrV1alphaCellType$inboundSchema,
+} from "./qcrv1alphacelltype.js";
+import {
+  QcrV1alphaNumberFormatCategory,
+  QcrV1alphaNumberFormatCategory$inboundSchema,
+} from "./qcrv1alphanumberformatcategory.js";
+import { Value, Value$inboundSchema } from "./value.js";
+
+/**
+ * ColumnDef defines a single column in a DataTable.
+ */
+export type QcrV1alphaColumnDef = {
+  /**
+   * `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;
+  /**
+   * header text
+   */
+  name?: string | undefined;
+  numberFormatCategory?: QcrV1alphaNumberFormatCategory | undefined;
+  type?: QcrV1alphaCellType | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaColumnDef$inboundSchema: z.ZodMiniType<
+  QcrV1alphaColumnDef,
+  unknown
+> = z.pipe(
+  z.object({
+    attributes: types.optional(
+      z.record(z.string(), types.nullable(Value$inboundSchema)),
+    ),
+    name: types.optional(types.string()),
+    number_format_category: types.optional(
+      QcrV1alphaNumberFormatCategory$inboundSchema,
+    ),
+    type: types.optional(QcrV1alphaCellType$inboundSchema),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "number_format_category": "numberFormatCategory",
+    });
+  }),
+);
+
+export function qcrV1alphaColumnDefFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaColumnDef, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaColumnDef$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaColumnDef' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphacolumnformatbinding.ts

@@ -0,0 +1,66 @@
+/*
+ * 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 {
+  QcrV1alphaNumberFormatCategory,
+  QcrV1alphaNumberFormatCategory$inboundSchema,
+} from "./qcrv1alphanumberformatcategory.js";
+
+/**
+ * Format binding for a column within a DataTable, used for rendering.
+ */
+export type QcrV1alphaColumnFormatBinding = {
+  /**
+   * index into DataTable.columns[]
+   */
+  columnIndex?: number | undefined;
+  numberFormatCategory?: QcrV1alphaNumberFormatCategory | undefined;
+  /**
+   * e.g. "#,##0.00", "yyyy-mm-dd", "0.00%"
+   */
+  numberFormatPattern?: string | undefined;
+  /**
+   * references DataTable.name
+   */
+  tableName?: string | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaColumnFormatBinding$inboundSchema: z.ZodMiniType<
+  QcrV1alphaColumnFormatBinding,
+  unknown
+> = z.pipe(
+  z.object({
+    column_index: types.optional(types.number()),
+    number_format_category: types.optional(
+      QcrV1alphaNumberFormatCategory$inboundSchema,
+    ),
+    number_format_pattern: types.optional(types.string()),
+    table_name: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "column_index": "columnIndex",
+      "number_format_category": "numberFormatCategory",
+      "number_format_pattern": "numberFormatPattern",
+      "table_name": "tableName",
+    });
+  }),
+);
+
+export function qcrV1alphaColumnFormatBindingFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaColumnFormatBinding, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaColumnFormatBinding$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaColumnFormatBinding' from JSON`,
+  );
+}

package/src/models/components/qcrv1alphacolumnlayout.ts

@@ -0,0 +1,44 @@
+/*
+ * 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 QcrV1alphaColumnLayout = {
+  col?: number | undefined;
+  isHidden?: boolean | undefined;
+  widthMm?: number | undefined;
+};
+
+/** @internal */
+export const QcrV1alphaColumnLayout$inboundSchema: z.ZodMiniType<
+  QcrV1alphaColumnLayout,
+  unknown
+> = z.pipe(
+  z.object({
+    col: types.optional(types.number()),
+    is_hidden: types.optional(types.boolean()),
+    width_mm: types.optional(types.number()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "is_hidden": "isHidden",
+      "width_mm": "widthMm",
+    });
+  }),
+);
+
+export function qcrV1alphaColumnLayoutFromJSON(
+  jsonString: string,
+): SafeParseResult<QcrV1alphaColumnLayout, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QcrV1alphaColumnLayout$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QcrV1alphaColumnLayout' from JSON`,
+  );
+}