box-node-sdk 10.2.0 → 10.3.0

package/src/schemas/metadataTaxonomy.ts

@@ -0,0 +1,119 @@
+import { serializeMetadataTaxonomyLevel } from './metadataTaxonomyLevel';
+import { deserializeMetadataTaxonomyLevel } from './metadataTaxonomyLevel';
+import { MetadataTaxonomyLevel } from './metadataTaxonomyLevel';
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export interface MetadataTaxonomy {
+  /**
+   * A unique identifier of the metadata taxonomy. */
+  readonly id: string;
+  /**
+   * A unique identifier of the metadata taxonomy. The identifier must be unique within
+   * the namespace to which it belongs. */
+  readonly key?: string;
+  /**
+   * The display name of the metadata taxonomy. This can be seen in the Box web app. */
+  readonly displayName: string;
+  /**
+   * A namespace that the metadata taxonomy is associated with. */
+  readonly namespace: string;
+  /**
+   * Levels of the metadata taxonomy. */
+  readonly levels?: readonly MetadataTaxonomyLevel[];
+  readonly rawData?: SerializedData;
+}
+export function serializeMetadataTaxonomy(
+  val: MetadataTaxonomy,
+): SerializedData {
+  return {
+    ['id']: val.id,
+    ['key']: val.key,
+    ['displayName']: val.displayName,
+    ['namespace']: val.namespace,
+    ['levels']:
+      val.levels == void 0
+        ? val.levels
+        : (val.levels.map(function (
+            item: MetadataTaxonomyLevel,
+          ): SerializedData {
+            return serializeMetadataTaxonomyLevel(item);
+          }) as readonly any[]),
+  };
+}
+export function deserializeMetadataTaxonomy(
+  val: SerializedData,
+): MetadataTaxonomy {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "MetadataTaxonomy"',
+    });
+  }
+  if (val.id == void 0) {
+    throw new BoxSdkError({
+      message: 'Expecting "id" of type "MetadataTaxonomy" to be defined',
+    });
+  }
+  if (!sdIsString(val.id)) {
+    throw new BoxSdkError({
+      message: 'Expecting string for "id" of type "MetadataTaxonomy"',
+    });
+  }
+  const id: string = val.id;
+  if (!(val.key == void 0) && !sdIsString(val.key)) {
+    throw new BoxSdkError({
+      message: 'Expecting string for "key" of type "MetadataTaxonomy"',
+    });
+  }
+  const key: undefined | string = val.key == void 0 ? void 0 : val.key;
+  if (val.displayName == void 0) {
+    throw new BoxSdkError({
+      message:
+        'Expecting "displayName" of type "MetadataTaxonomy" to be defined',
+    });
+  }
+  if (!sdIsString(val.displayName)) {
+    throw new BoxSdkError({
+      message: 'Expecting string for "displayName" of type "MetadataTaxonomy"',
+    });
+  }
+  const displayName: string = val.displayName;
+  if (val.namespace == void 0) {
+    throw new BoxSdkError({
+      message: 'Expecting "namespace" of type "MetadataTaxonomy" to be defined',
+    });
+  }
+  if (!sdIsString(val.namespace)) {
+    throw new BoxSdkError({
+      message: 'Expecting string for "namespace" of type "MetadataTaxonomy"',
+    });
+  }
+  const namespace: string = val.namespace;
+  if (!(val.levels == void 0) && !sdIsList(val.levels)) {
+    throw new BoxSdkError({
+      message: 'Expecting array for "levels" of type "MetadataTaxonomy"',
+    });
+  }
+  const levels: undefined | readonly MetadataTaxonomyLevel[] =
+    val.levels == void 0
+      ? void 0
+      : sdIsList(val.levels)
+        ? (val.levels.map(function (
+            itm: SerializedData,
+          ): MetadataTaxonomyLevel {
+            return deserializeMetadataTaxonomyLevel(itm);
+          }) as readonly any[])
+        : [];
+  return {
+    id: id,
+    key: key,
+    displayName: displayName,
+    namespace: namespace,
+    levels: levels,
+  } satisfies MetadataTaxonomy;
+}

package/src/schemas/metadataTaxonomyAncestor.ts

@@ -0,0 +1,64 @@
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export interface MetadataTaxonomyAncestor {
+  /**
+   * A unique identifier of the metadata taxonomy node. */
+  readonly id?: string;
+  /**
+   * The display name of the metadata taxonomy node. */
+  readonly displayName?: string;
+  /**
+   * An index of the level to which the node belongs. */
+  readonly level?: number;
+  readonly rawData?: SerializedData;
+}
+export function serializeMetadataTaxonomyAncestor(
+  val: MetadataTaxonomyAncestor,
+): SerializedData {
+  return {
+    ['id']: val.id,
+    ['displayName']: val.displayName,
+    ['level']: val.level,
+  };
+}
+export function deserializeMetadataTaxonomyAncestor(
+  val: SerializedData,
+): MetadataTaxonomyAncestor {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "MetadataTaxonomyAncestor"',
+    });
+  }
+  if (!(val.id == void 0) && !sdIsString(val.id)) {
+    throw new BoxSdkError({
+      message: 'Expecting string for "id" of type "MetadataTaxonomyAncestor"',
+    });
+  }
+  const id: undefined | string = val.id == void 0 ? void 0 : val.id;
+  if (!(val.displayName == void 0) && !sdIsString(val.displayName)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "displayName" of type "MetadataTaxonomyAncestor"',
+    });
+  }
+  const displayName: undefined | string =
+    val.displayName == void 0 ? void 0 : val.displayName;
+  if (!(val.level == void 0) && !sdIsNumber(val.level)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting number for "level" of type "MetadataTaxonomyAncestor"',
+    });
+  }
+  const level: undefined | number = val.level == void 0 ? void 0 : val.level;
+  return {
+    id: id,
+    displayName: displayName,
+    level: level,
+  } satisfies MetadataTaxonomyAncestor;
+}

package/src/schemas/metadataTaxonomyLevel.ts

@@ -0,0 +1,65 @@
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export interface MetadataTaxonomyLevel {
+  /**
+   * The display name of the level as it is shown to the user. */
+  readonly displayName?: string;
+  /**
+   * A description of the level. */
+  readonly description?: string;
+  /**
+   * An index of the level within the taxonomy. Levels are indexed starting from 1. */
+  readonly level?: number;
+  readonly rawData?: SerializedData;
+}
+export function serializeMetadataTaxonomyLevel(
+  val: MetadataTaxonomyLevel,
+): SerializedData {
+  return {
+    ['displayName']: val.displayName,
+    ['description']: val.description,
+    ['level']: val.level,
+  };
+}
+export function deserializeMetadataTaxonomyLevel(
+  val: SerializedData,
+): MetadataTaxonomyLevel {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "MetadataTaxonomyLevel"',
+    });
+  }
+  if (!(val.displayName == void 0) && !sdIsString(val.displayName)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "displayName" of type "MetadataTaxonomyLevel"',
+    });
+  }
+  const displayName: undefined | string =
+    val.displayName == void 0 ? void 0 : val.displayName;
+  if (!(val.description == void 0) && !sdIsString(val.description)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "description" of type "MetadataTaxonomyLevel"',
+    });
+  }
+  const description: undefined | string =
+    val.description == void 0 ? void 0 : val.description;
+  if (!(val.level == void 0) && !sdIsNumber(val.level)) {
+    throw new BoxSdkError({
+      message: 'Expecting number for "level" of type "MetadataTaxonomyLevel"',
+    });
+  }
+  const level: undefined | number = val.level == void 0 ? void 0 : val.level;
+  return {
+    displayName: displayName,
+    description: description,
+    level: level,
+  } satisfies MetadataTaxonomyLevel;
+}

package/src/schemas/metadataTaxonomyLevels.ts

@@ -0,0 +1,56 @@
+import { serializeMetadataTaxonomyLevel } from './metadataTaxonomyLevel';
+import { deserializeMetadataTaxonomyLevel } from './metadataTaxonomyLevel';
+import { MetadataTaxonomyLevel } from './metadataTaxonomyLevel';
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export interface MetadataTaxonomyLevels {
+  /**
+   * An array of all taxonomy levels. */
+  readonly entries?: readonly MetadataTaxonomyLevel[];
+  readonly rawData?: SerializedData;
+}
+export function serializeMetadataTaxonomyLevels(
+  val: MetadataTaxonomyLevels,
+): SerializedData {
+  return {
+    ['entries']:
+      val.entries == void 0
+        ? val.entries
+        : (val.entries.map(function (
+            item: MetadataTaxonomyLevel,
+          ): SerializedData {
+            return serializeMetadataTaxonomyLevel(item);
+          }) as readonly any[]),
+  };
+}
+export function deserializeMetadataTaxonomyLevels(
+  val: SerializedData,
+): MetadataTaxonomyLevels {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "MetadataTaxonomyLevels"',
+    });
+  }
+  if (!(val.entries == void 0) && !sdIsList(val.entries)) {
+    throw new BoxSdkError({
+      message: 'Expecting array for "entries" of type "MetadataTaxonomyLevels"',
+    });
+  }
+  const entries: undefined | readonly MetadataTaxonomyLevel[] =
+    val.entries == void 0
+      ? void 0
+      : sdIsList(val.entries)
+        ? (val.entries.map(function (
+            itm: SerializedData,
+          ): MetadataTaxonomyLevel {
+            return deserializeMetadataTaxonomyLevel(itm);
+          }) as readonly any[])
+        : [];
+  return { entries: entries } satisfies MetadataTaxonomyLevels;
+}

package/src/schemas/metadataTaxonomyNode.ts

@@ -0,0 +1,150 @@
+import { serializeMetadataTaxonomyAncestor } from './metadataTaxonomyAncestor';
+import { deserializeMetadataTaxonomyAncestor } from './metadataTaxonomyAncestor';
+import { MetadataTaxonomyAncestor } from './metadataTaxonomyAncestor';
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export interface MetadataTaxonomyNode {
+  /**
+   * A unique identifier of the metadata taxonomy node. */
+  readonly id: string;
+  /**
+   * The display name of the metadata taxonomy node. */
+  readonly displayName: string;
+  /**
+   * An index of the level to which the node belongs. */
+  readonly level: number;
+  /**
+   * The identifier of the parent node. */
+  readonly parentId?: string;
+  /**
+   * An array of identifiers for all ancestor nodes.
+   * Not returned for root-level nodes. */
+  readonly nodePath?: readonly string[];
+  /**
+   * An array of objects for all ancestor nodes.
+   * Not returned for root-level nodes. */
+  readonly ancestors?: readonly MetadataTaxonomyAncestor[];
+  readonly rawData?: SerializedData;
+}
+export function serializeMetadataTaxonomyNode(
+  val: MetadataTaxonomyNode,
+): SerializedData {
+  return {
+    ['id']: val.id,
+    ['displayName']: val.displayName,
+    ['level']: val.level,
+    ['parentId']: val.parentId,
+    ['nodePath']:
+      val.nodePath == void 0
+        ? val.nodePath
+        : (val.nodePath.map(function (item: string): SerializedData {
+            return item;
+          }) as readonly any[]),
+    ['ancestors']:
+      val.ancestors == void 0
+        ? val.ancestors
+        : (val.ancestors.map(function (
+            item: MetadataTaxonomyAncestor,
+          ): SerializedData {
+            return serializeMetadataTaxonomyAncestor(item);
+          }) as readonly any[]),
+  };
+}
+export function deserializeMetadataTaxonomyNode(
+  val: SerializedData,
+): MetadataTaxonomyNode {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "MetadataTaxonomyNode"',
+    });
+  }
+  if (val.id == void 0) {
+    throw new BoxSdkError({
+      message: 'Expecting "id" of type "MetadataTaxonomyNode" to be defined',
+    });
+  }
+  if (!sdIsString(val.id)) {
+    throw new BoxSdkError({
+      message: 'Expecting string for "id" of type "MetadataTaxonomyNode"',
+    });
+  }
+  const id: string = val.id;
+  if (val.displayName == void 0) {
+    throw new BoxSdkError({
+      message:
+        'Expecting "displayName" of type "MetadataTaxonomyNode" to be defined',
+    });
+  }
+  if (!sdIsString(val.displayName)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "displayName" of type "MetadataTaxonomyNode"',
+    });
+  }
+  const displayName: string = val.displayName;
+  if (val.level == void 0) {
+    throw new BoxSdkError({
+      message: 'Expecting "level" of type "MetadataTaxonomyNode" to be defined',
+    });
+  }
+  if (!sdIsNumber(val.level)) {
+    throw new BoxSdkError({
+      message: 'Expecting number for "level" of type "MetadataTaxonomyNode"',
+    });
+  }
+  const level: number = val.level;
+  if (!(val.parentId == void 0) && !sdIsString(val.parentId)) {
+    throw new BoxSdkError({
+      message: 'Expecting string for "parentId" of type "MetadataTaxonomyNode"',
+    });
+  }
+  const parentId: undefined | string =
+    val.parentId == void 0 ? void 0 : val.parentId;
+  if (!(val.nodePath == void 0) && !sdIsList(val.nodePath)) {
+    throw new BoxSdkError({
+      message: 'Expecting array for "nodePath" of type "MetadataTaxonomyNode"',
+    });
+  }
+  const nodePath: undefined | readonly string[] =
+    val.nodePath == void 0
+      ? void 0
+      : sdIsList(val.nodePath)
+        ? (val.nodePath.map(function (itm: SerializedData): string {
+            if (!sdIsString(itm)) {
+              throw new BoxSdkError({
+                message: 'Expecting string for "MetadataTaxonomyNode"',
+              });
+            }
+            return itm;
+          }) as readonly any[])
+        : [];
+  if (!(val.ancestors == void 0) && !sdIsList(val.ancestors)) {
+    throw new BoxSdkError({
+      message: 'Expecting array for "ancestors" of type "MetadataTaxonomyNode"',
+    });
+  }
+  const ancestors: undefined | readonly MetadataTaxonomyAncestor[] =
+    val.ancestors == void 0
+      ? void 0
+      : sdIsList(val.ancestors)
+        ? (val.ancestors.map(function (
+            itm: SerializedData,
+          ): MetadataTaxonomyAncestor {
+            return deserializeMetadataTaxonomyAncestor(itm);
+          }) as readonly any[])
+        : [];
+  return {
+    id: id,
+    displayName: displayName,
+    level: level,
+    parentId: parentId,
+    nodePath: nodePath,
+    ancestors: ancestors,
+  } satisfies MetadataTaxonomyNode;
+}

package/src/schemas/metadataTaxonomyNodes.ts

@@ -0,0 +1,97 @@
+import { serializeMetadataTaxonomyNode } from './metadataTaxonomyNode';
+import { deserializeMetadataTaxonomyNode } from './metadataTaxonomyNode';
+import { MetadataTaxonomyNode } from './metadataTaxonomyNode';
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export interface MetadataTaxonomyNodes {
+  /**
+   * The limit that was used for these entries. This will be the same as the
+   * `limit` query parameter unless that value exceeded the maximum value
+   * allowed. The maximum value varies by API. */
+  readonly limit?: number;
+  /**
+   * The marker for the start of the next page of results. */
+  readonly nextMarker?: string | null;
+  /**
+   * The marker for the start of the previous page of results. */
+  readonly prevMarker?: string | null;
+  /**
+   * A list of metadata taxonomy nodes. */
+  readonly entries?: readonly MetadataTaxonomyNode[];
+  readonly rawData?: SerializedData;
+}
+export function serializeMetadataTaxonomyNodes(
+  val: MetadataTaxonomyNodes,
+): SerializedData {
+  return {
+    ['limit']: val.limit,
+    ['next_marker']: val.nextMarker,
+    ['prev_marker']: val.prevMarker,
+    ['entries']:
+      val.entries == void 0
+        ? val.entries
+        : (val.entries.map(function (
+            item: MetadataTaxonomyNode,
+          ): SerializedData {
+            return serializeMetadataTaxonomyNode(item);
+          }) as readonly any[]),
+  };
+}
+export function deserializeMetadataTaxonomyNodes(
+  val: SerializedData,
+): MetadataTaxonomyNodes {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "MetadataTaxonomyNodes"',
+    });
+  }
+  if (!(val.limit == void 0) && !sdIsNumber(val.limit)) {
+    throw new BoxSdkError({
+      message: 'Expecting number for "limit" of type "MetadataTaxonomyNodes"',
+    });
+  }
+  const limit: undefined | number = val.limit == void 0 ? void 0 : val.limit;
+  if (!(val.next_marker == void 0) && !sdIsString(val.next_marker)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "next_marker" of type "MetadataTaxonomyNodes"',
+    });
+  }
+  const nextMarker: undefined | string =
+    val.next_marker == void 0 ? void 0 : val.next_marker;
+  if (!(val.prev_marker == void 0) && !sdIsString(val.prev_marker)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "prev_marker" of type "MetadataTaxonomyNodes"',
+    });
+  }
+  const prevMarker: undefined | string =
+    val.prev_marker == void 0 ? void 0 : val.prev_marker;
+  if (!(val.entries == void 0) && !sdIsList(val.entries)) {
+    throw new BoxSdkError({
+      message: 'Expecting array for "entries" of type "MetadataTaxonomyNodes"',
+    });
+  }
+  const entries: undefined | readonly MetadataTaxonomyNode[] =
+    val.entries == void 0
+      ? void 0
+      : sdIsList(val.entries)
+        ? (val.entries.map(function (
+            itm: SerializedData,
+          ): MetadataTaxonomyNode {
+            return deserializeMetadataTaxonomyNode(itm);
+          }) as readonly any[])
+        : [];
+  return {
+    limit: limit,
+    nextMarker: nextMarker,
+    prevMarker: prevMarker,
+    entries: entries,
+  } satisfies MetadataTaxonomyNodes;
+}

package/src/schemas/metadataTemplate.ts

@@ -13,7 +13,8 @@ export type MetadataTemplateFieldsTypeField =
   | 'date'
   | 'enum'
   | 'multiSelect'
-  | 'integer';
+  | 'integer'
+  | 'taxonomy';
 export interface MetadataTemplateFieldsOptionsField {
   /**
    * The text value of the option. This represents both the display name of the
@@ -210,6 +211,9 @@ export function deserializeMetadataTemplateFieldsTypeField(
   if (val == 'integer') {
     return val;
   }
+  if (val == 'taxonomy') {
+    return val;
+  }
   throw new BoxSdkError({
     message: "Can't deserialize MetadataTemplateFieldsTypeField",
   });

package/src/schemas/signRequestCreateRequest.ts

@@ -37,7 +37,7 @@ export type SignRequestCreateRequest = SignRequestBase & {
    * Array of signers for the signature request. 35 is the
    * max number of signers permitted.
    *
-   * **Note**: It may happen that some signers belong to conflicting [segments](r://shield-information-barrier-segment-member) (user groups).
+   * **Note**: It may happen that some signers belong to conflicting [segments](https://developer.box.com/reference/resources/shield-information-barrier-segment-member) (user groups).
    * This means that due to the security policies, users are assigned to segments to prevent exchanges or communication that could lead to ethical conflicts.
    * In such a case, an attempt to send the sign request will result in an error.
    *

package/src/schemas/signRequestSignerInput.ts

@@ -1,9 +1,45 @@
 import { serializeDate } from '../internal/utils';
 import { deserializeDate } from '../internal/utils';
+import { serializeSignRequestSignerInputEmailValidation } from './signRequestSignerInputEmailValidation';
+import { deserializeSignRequestSignerInputEmailValidation } from './signRequestSignerInputEmailValidation';
+import { serializeSignRequestSignerInputCustomValidation } from './signRequestSignerInputCustomValidation';
+import { deserializeSignRequestSignerInputCustomValidation } from './signRequestSignerInputCustomValidation';
+import { serializeSignRequestSignerInputZipValidation } from './signRequestSignerInputZipValidation';
+import { deserializeSignRequestSignerInputZipValidation } from './signRequestSignerInputZipValidation';
+import { serializeSignRequestSignerInputZip4Validation } from './signRequestSignerInputZip4Validation';
+import { deserializeSignRequestSignerInputZip4Validation } from './signRequestSignerInputZip4Validation';
+import { serializeSignRequestSignerInputSsnValidation } from './signRequestSignerInputSsnValidation';
+import { deserializeSignRequestSignerInputSsnValidation } from './signRequestSignerInputSsnValidation';
+import { serializeSignRequestSignerInputNumberWithPeriodValidation } from './signRequestSignerInputNumberWithPeriodValidation';
+import { deserializeSignRequestSignerInputNumberWithPeriodValidation } from './signRequestSignerInputNumberWithPeriodValidation';
+import { serializeSignRequestSignerInputNumberWithCommaValidation } from './signRequestSignerInputNumberWithCommaValidation';
+import { deserializeSignRequestSignerInputNumberWithCommaValidation } from './signRequestSignerInputNumberWithCommaValidation';
+import { serializeSignRequestSignerInputDateIsoValidation } from './signRequestSignerInputDateIsoValidation';
+import { deserializeSignRequestSignerInputDateIsoValidation } from './signRequestSignerInputDateIsoValidation';
+import { serializeSignRequestSignerInputDateUsValidation } from './signRequestSignerInputDateUsValidation';
+import { deserializeSignRequestSignerInputDateUsValidation } from './signRequestSignerInputDateUsValidation';
+import { serializeSignRequestSignerInputDateEuValidation } from './signRequestSignerInputDateEuValidation';
+import { deserializeSignRequestSignerInputDateEuValidation } from './signRequestSignerInputDateEuValidation';
+import { serializeSignRequestSignerInputDateAsiaValidation } from './signRequestSignerInputDateAsiaValidation';
+import { deserializeSignRequestSignerInputDateAsiaValidation } from './signRequestSignerInputDateAsiaValidation';
 import { serializeSignRequestPrefillTag } from './signRequestPrefillTag';
 import { deserializeSignRequestPrefillTag } from './signRequestPrefillTag';
+import { serializeSignRequestSignerInputValidation } from './signRequestSignerInputValidation';
+import { deserializeSignRequestSignerInputValidation } from './signRequestSignerInputValidation';
 import { Date } from '../internal/utils';
+import { SignRequestSignerInputEmailValidation } from './signRequestSignerInputEmailValidation';
+import { SignRequestSignerInputCustomValidation } from './signRequestSignerInputCustomValidation';
+import { SignRequestSignerInputZipValidation } from './signRequestSignerInputZipValidation';
+import { SignRequestSignerInputZip4Validation } from './signRequestSignerInputZip4Validation';
+import { SignRequestSignerInputSsnValidation } from './signRequestSignerInputSsnValidation';
+import { SignRequestSignerInputNumberWithPeriodValidation } from './signRequestSignerInputNumberWithPeriodValidation';
+import { SignRequestSignerInputNumberWithCommaValidation } from './signRequestSignerInputNumberWithCommaValidation';
+import { SignRequestSignerInputDateIsoValidation } from './signRequestSignerInputDateIsoValidation';
+import { SignRequestSignerInputDateUsValidation } from './signRequestSignerInputDateUsValidation';
+import { SignRequestSignerInputDateEuValidation } from './signRequestSignerInputDateEuValidation';
+import { SignRequestSignerInputDateAsiaValidation } from './signRequestSignerInputDateAsiaValidation';
 import { SignRequestPrefillTag } from './signRequestPrefillTag';
+import { SignRequestSignerInputValidation } from './signRequestSignerInputValidation';
 import { BoxSdkError } from '../box/errors';
 import { SerializedData } from '../serialization/json';
 import { sdIsEmpty } from '../serialization/json';
@@ -47,8 +83,12 @@ export type SignRequestSignerInput = SignRequestPrefillTag & {
    * Index of page that the input is on. */
   readonly pageIndex: number;
   /**
-   * Whether this input was defined as read-only(immutable by signers) or not. */
+   * Indicates whether this input is read-only (cannot be modified by signers). */
   readonly readOnly?: boolean;
+  /**
+   * Specifies the formatting rules that signers must follow for text field inputs.
+   * If set, this validation is mandatory. */
+  readonly validation?: SignRequestSignerInputValidation;
 };
 export function serializeSignRequestSignerInputTypeField(
   val: SignRequestSignerInputTypeField,
@@ -162,6 +202,10 @@ export function serializeSignRequestSignerInput(
           : serializeSignRequestSignerInputContentTypeField(val.contentType),
       ['page_index']: val.pageIndex,
       ['read_only']: val.readOnly,
+      ['validation']:
+        val.validation == void 0
+          ? val.validation
+          : serializeSignRequestSignerInputValidation(val.validation),
     },
   };
 }
@@ -202,6 +246,10 @@ export function deserializeSignRequestSignerInput(
   }
   const readOnly: undefined | boolean =
     val.read_only == void 0 ? void 0 : val.read_only;
+  const validation: SignRequestSignerInputValidation | undefined =
+    val.validation == void 0
+      ? void 0
+      : deserializeSignRequestSignerInputValidation(val.validation);
   if (!(val.document_tag_id == void 0) && !sdIsString(val.document_tag_id)) {
     throw new BoxSdkError({
       message:
@@ -239,6 +287,7 @@ export function deserializeSignRequestSignerInput(
     contentType: contentType,
     pageIndex: pageIndex,
     readOnly: readOnly,
+    validation: validation,
     documentTagId: documentTagId,
     textValue: textValue,
     checkboxValue: checkboxValue,