box-node-sdk 10.1.0 → 10.3.0

package/src/schemas/aiAgentReference.ts

@@ -15,7 +15,7 @@ export class AiAgentReference {
   /**
    * The ID of an Agent. This can be a numeric ID for custom agents (for example, `14031`)
    * or a unique identifier for pre-built agents (for example, `enhanced_extract_agent`
-   * for the [Enhanced Extract Agent](g://box-ai/ai-tutorials/extract-metadata-structured/#enhanced-extract-agent)). */
+   * for the [Enhanced Extract Agent](https://developer.box.com/guides/box-ai/ai-tutorials/extract-metadata-structured#enhanced-extract-agent)). */
   readonly id?: string;
   readonly rawData?: SerializedData;
   constructor(
@@ -40,7 +40,7 @@ export interface AiAgentReferenceInput {
   /**
    * The ID of an Agent. This can be a numeric ID for custom agents (for example, `14031`)
    * or a unique identifier for pre-built agents (for example, `enhanced_extract_agent`
-   * for the [Enhanced Extract Agent](g://box-ai/ai-tutorials/extract-metadata-structured/#enhanced-extract-agent)). */
+   * for the [Enhanced Extract Agent](https://developer.box.com/guides/box-ai/ai-tutorials/extract-metadata-structured#enhanced-extract-agent)). */
   readonly id?: string;
   readonly rawData?: SerializedData;
 }

package/src/schemas/aiAgentSpreadsheetTool.ts

@@ -23,7 +23,7 @@ import { sdIsList } from '../serialization/json';
 import { sdIsMap } from '../serialization/json';
 export interface AiAgentSpreadsheetTool {
   /**
-   * The model used for the AI agent for spreadsheets. For specific model values, see the [available models list](g://box-ai/supported-models). */
+   * The model used for the AI agent for spreadsheets. For specific model values, see the [available models list](https://developer.box.com/guides/box-ai/supported-models). */
   readonly model?: string;
   /**
    * The number of tokens for completion. */

package/src/schemas/index.ts

@@ -109,6 +109,13 @@ export * from './metadataFilterValue';
 export * from './metadataFilter';
 export * from './metadataInstanceValue';
 export * from './metadataQuery';
+export * from './metadataTaxonomyAncestor';
+export * from './metadataTaxonomyNode';
+export * from './metadataTaxonomyNodes';
+export * from './metadataTaxonomyLevel';
+export * from './metadataTaxonomyLevels';
+export * from './metadataTaxonomy';
+export * from './metadataTaxonomies';
 export * from './metadataTemplate';
 export * from './metadataTemplates';
 export * from './oAuth2Error';
@@ -133,14 +140,27 @@ export * from './shieldInformationBarrierSegmentRestrictionBase';
 export * from './shieldInformationBarrierSegmentRestrictionMini';
 export * from './signRequestCreateSigner';
 export * from './signRequestPrefillTag';
+export * from './signRequestBase';
+export * from './signRequestCreateRequest';
+export * from './signRequestSignerAttachment';
+export * from './signRequestSignerInputCustomValidation';
+export * from './signRequestSignerInputDateAsiaValidation';
+export * from './signRequestSignerInputDateEuValidation';
+export * from './signRequestSignerInputDateIsoValidation';
+export * from './signRequestSignerInputDateUsValidation';
+export * from './signRequestSignerInputEmailValidation';
+export * from './signRequestSignerInputNumberWithCommaValidation';
+export * from './signRequestSignerInputNumberWithPeriodValidation';
+export * from './signRequestSignerInputSsnValidation';
+export * from './signRequestSignerInputZip4Validation';
+export * from './signRequestSignerInputZipValidation';
+export * from './signRequestSignerInputValidation';
 export * from './templateSignerInput';
 export * from './templateSigner';
 export * from './signTemplate';
 export * from './signTemplates';
 export * from './signRequestSignerInput';
 export * from './signRequestSigner';
-export * from './signRequestBase';
-export * from './signRequestCreateRequest';
 export * from './signRequest';
 export * from './signRequests';
 export * from './statusSkillCard';

package/src/schemas/metadataCascadePolicy.ts

@@ -61,9 +61,9 @@ export class MetadataCascadePolicy {
    * get all instances on a [file][file] or [folder][folder]
    * to inspect a template's key.
    *
-   * [list]: e://get-metadata-templates-enterprise
-   * [file]: e://get-files-id-metadata
-   * [folder]: e://get-folders-id-metadata */
+   * [list]: https://developer.box.com/reference/get-metadata-templates-enterprise
+   * [file]: https://developer.box.com/reference/get-files-id-metadata
+   * [folder]: https://developer.box.com/reference/get-folders-id-metadata */
   readonly templateKey?: string;
   readonly rawData?: SerializedData;
   constructor(
@@ -126,9 +126,9 @@ export interface MetadataCascadePolicyInput {
    * get all instances on a [file][file] or [folder][folder]
    * to inspect a template's key.
    *
-   * [list]: e://get-metadata-templates-enterprise
-   * [file]: e://get-files-id-metadata
-   * [folder]: e://get-folders-id-metadata */
+   * [list]: https://developer.box.com/reference/get-metadata-templates-enterprise
+   * [file]: https://developer.box.com/reference/get-files-id-metadata
+   * [folder]: https://developer.box.com/reference/get-folders-id-metadata */
   readonly templateKey?: string;
   readonly rawData?: SerializedData;
 }

package/src/schemas/metadataFilter.ts

@@ -40,9 +40,9 @@ export interface MetadataFilter {
    * get all instances on a [file][file] or [folder][folder]
    * to inspect a template's key.
    *
-   * [list]: e://get-metadata-templates-enterprise
-   * [file]: e://get-files-id-metadata
-   * [folder]: e://get-folders-id-metadata */
+   * [list]: https://developer.box.com/reference/get-metadata-templates-enterprise
+   * [file]: https://developer.box.com/reference/get-files-id-metadata
+   * [folder]: https://developer.box.com/reference/get-folders-id-metadata */
   readonly templateKey?: string;
   /**
    * Specifies which fields on the template to filter the search

package/src/schemas/metadataTaxonomies.ts

@@ -0,0 +1,93 @@
+import { serializeMetadataTaxonomy } from './metadataTaxonomy';
+import { deserializeMetadataTaxonomy } from './metadataTaxonomy';
+import { MetadataTaxonomy } from './metadataTaxonomy';
+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 MetadataTaxonomies {
+  /**
+   * 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 taxonomies. */
+  readonly entries?: readonly MetadataTaxonomy[];
+  readonly rawData?: SerializedData;
+}
+export function serializeMetadataTaxonomies(
+  val: MetadataTaxonomies,
+): 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: MetadataTaxonomy): SerializedData {
+            return serializeMetadataTaxonomy(item);
+          }) as readonly any[]),
+  };
+}
+export function deserializeMetadataTaxonomies(
+  val: SerializedData,
+): MetadataTaxonomies {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "MetadataTaxonomies"',
+    });
+  }
+  if (!(val.limit == void 0) && !sdIsNumber(val.limit)) {
+    throw new BoxSdkError({
+      message: 'Expecting number for "limit" of type "MetadataTaxonomies"',
+    });
+  }
+  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 "MetadataTaxonomies"',
+    });
+  }
+  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 "MetadataTaxonomies"',
+    });
+  }
+  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 "MetadataTaxonomies"',
+    });
+  }
+  const entries: undefined | readonly MetadataTaxonomy[] =
+    val.entries == void 0
+      ? void 0
+      : sdIsList(val.entries)
+        ? (val.entries.map(function (itm: SerializedData): MetadataTaxonomy {
+            return deserializeMetadataTaxonomy(itm);
+          }) as readonly any[])
+        : [];
+  return {
+    limit: limit,
+    nextMarker: nextMarker,
+    prevMarker: prevMarker,
+    entries: entries,
+  } satisfies MetadataTaxonomies;
+}

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;
+}