box-node-sdk 10.2.0 → 10.4.0

package/src/managers/metadataTaxonomies.ts

@@ -0,0 +1,2030 @@
+import { serializeMetadataTaxonomy } from '../schemas/metadataTaxonomy';
+import { deserializeMetadataTaxonomy } from '../schemas/metadataTaxonomy';
+import { serializeClientError } from '../schemas/clientError';
+import { deserializeClientError } from '../schemas/clientError';
+import { serializeMetadataTaxonomies } from '../schemas/metadataTaxonomies';
+import { deserializeMetadataTaxonomies } from '../schemas/metadataTaxonomies';
+import { serializeMetadataTaxonomyLevels } from '../schemas/metadataTaxonomyLevels';
+import { deserializeMetadataTaxonomyLevels } from '../schemas/metadataTaxonomyLevels';
+import { serializeMetadataTaxonomyLevel } from '../schemas/metadataTaxonomyLevel';
+import { deserializeMetadataTaxonomyLevel } from '../schemas/metadataTaxonomyLevel';
+import { serializeMetadataTaxonomyNodes } from '../schemas/metadataTaxonomyNodes';
+import { deserializeMetadataTaxonomyNodes } from '../schemas/metadataTaxonomyNodes';
+import { serializeMetadataTaxonomyNode } from '../schemas/metadataTaxonomyNode';
+import { deserializeMetadataTaxonomyNode } from '../schemas/metadataTaxonomyNode';
+import { ResponseFormat } from '../networking/fetchOptions';
+import { MetadataTaxonomy } from '../schemas/metadataTaxonomy';
+import { ClientError } from '../schemas/clientError';
+import { MetadataTaxonomies } from '../schemas/metadataTaxonomies';
+import { MetadataTaxonomyLevels } from '../schemas/metadataTaxonomyLevels';
+import { MetadataTaxonomyLevel } from '../schemas/metadataTaxonomyLevel';
+import { MetadataTaxonomyNodes } from '../schemas/metadataTaxonomyNodes';
+import { MetadataTaxonomyNode } from '../schemas/metadataTaxonomyNode';
+import { BoxSdkError } from '../box/errors';
+import { Authentication } from '../networking/auth';
+import { NetworkSession } from '../networking/network';
+import { FetchOptions } from '../networking/fetchOptions';
+import { FetchResponse } from '../networking/fetchResponse';
+import { prepareParams } from '../internal/utils';
+import { toString } from '../internal/utils';
+import { ByteStream } from '../internal/utils';
+import { CancellationToken } from '../internal/utils';
+import { SerializedData } from '../serialization/json';
+import { sdToJson } 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 class CreateMetadataTaxonomyOptionals {
+  readonly headers: CreateMetadataTaxonomyHeaders =
+    new CreateMetadataTaxonomyHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      CreateMetadataTaxonomyOptionals,
+      'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<CreateMetadataTaxonomyOptionals, 'headers' | 'cancellationToken'>
+      >,
+  ) {
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface CreateMetadataTaxonomyOptionalsInput {
+  readonly headers?: CreateMetadataTaxonomyHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class GetMetadataTaxonomiesOptionals {
+  readonly queryParams: GetMetadataTaxonomiesQueryParams =
+    {} satisfies GetMetadataTaxonomiesQueryParams;
+  readonly headers: GetMetadataTaxonomiesHeaders =
+    new GetMetadataTaxonomiesHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      GetMetadataTaxonomiesOptionals,
+      'queryParams' | 'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<
+          GetMetadataTaxonomiesOptionals,
+          'queryParams' | 'headers' | 'cancellationToken'
+        >
+      >,
+  ) {
+    if (fields.queryParams !== undefined) {
+      this.queryParams = fields.queryParams;
+    }
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface GetMetadataTaxonomiesOptionalsInput {
+  readonly queryParams?: GetMetadataTaxonomiesQueryParams;
+  readonly headers?: GetMetadataTaxonomiesHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class GetMetadataTaxonomyByKeyOptionals {
+  readonly headers: GetMetadataTaxonomyByKeyHeaders =
+    new GetMetadataTaxonomyByKeyHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      GetMetadataTaxonomyByKeyOptionals,
+      'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<GetMetadataTaxonomyByKeyOptionals, 'headers' | 'cancellationToken'>
+      >,
+  ) {
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface GetMetadataTaxonomyByKeyOptionalsInput {
+  readonly headers?: GetMetadataTaxonomyByKeyHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class UpdateMetadataTaxonomyOptionals {
+  readonly headers: UpdateMetadataTaxonomyHeaders =
+    new UpdateMetadataTaxonomyHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      UpdateMetadataTaxonomyOptionals,
+      'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<UpdateMetadataTaxonomyOptionals, 'headers' | 'cancellationToken'>
+      >,
+  ) {
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface UpdateMetadataTaxonomyOptionalsInput {
+  readonly headers?: UpdateMetadataTaxonomyHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class DeleteMetadataTaxonomyOptionals {
+  readonly headers: DeleteMetadataTaxonomyHeaders =
+    new DeleteMetadataTaxonomyHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      DeleteMetadataTaxonomyOptionals,
+      'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<DeleteMetadataTaxonomyOptionals, 'headers' | 'cancellationToken'>
+      >,
+  ) {
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface DeleteMetadataTaxonomyOptionalsInput {
+  readonly headers?: DeleteMetadataTaxonomyHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class CreateMetadataTaxonomyLevelOptionals {
+  readonly headers: CreateMetadataTaxonomyLevelHeaders =
+    new CreateMetadataTaxonomyLevelHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      CreateMetadataTaxonomyLevelOptionals,
+      'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<
+          CreateMetadataTaxonomyLevelOptionals,
+          'headers' | 'cancellationToken'
+        >
+      >,
+  ) {
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface CreateMetadataTaxonomyLevelOptionalsInput {
+  readonly headers?: CreateMetadataTaxonomyLevelHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class UpdateMetadataTaxonomyLevelByIdOptionals {
+  readonly headers: UpdateMetadataTaxonomyLevelByIdHeaders =
+    new UpdateMetadataTaxonomyLevelByIdHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      UpdateMetadataTaxonomyLevelByIdOptionals,
+      'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<
+          UpdateMetadataTaxonomyLevelByIdOptionals,
+          'headers' | 'cancellationToken'
+        >
+      >,
+  ) {
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface UpdateMetadataTaxonomyLevelByIdOptionalsInput {
+  readonly headers?: UpdateMetadataTaxonomyLevelByIdHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class AddMetadataTaxonomyLevelOptionals {
+  readonly headers: AddMetadataTaxonomyLevelHeaders =
+    new AddMetadataTaxonomyLevelHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      AddMetadataTaxonomyLevelOptionals,
+      'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<AddMetadataTaxonomyLevelOptionals, 'headers' | 'cancellationToken'>
+      >,
+  ) {
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface AddMetadataTaxonomyLevelOptionalsInput {
+  readonly headers?: AddMetadataTaxonomyLevelHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class DeleteMetadataTaxonomyLevelOptionals {
+  readonly headers: DeleteMetadataTaxonomyLevelHeaders =
+    new DeleteMetadataTaxonomyLevelHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      DeleteMetadataTaxonomyLevelOptionals,
+      'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<
+          DeleteMetadataTaxonomyLevelOptionals,
+          'headers' | 'cancellationToken'
+        >
+      >,
+  ) {
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface DeleteMetadataTaxonomyLevelOptionalsInput {
+  readonly headers?: DeleteMetadataTaxonomyLevelHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class GetMetadataTaxonomyNodesOptionals {
+  readonly queryParams: GetMetadataTaxonomyNodesQueryParams =
+    {} satisfies GetMetadataTaxonomyNodesQueryParams;
+  readonly headers: GetMetadataTaxonomyNodesHeaders =
+    new GetMetadataTaxonomyNodesHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      GetMetadataTaxonomyNodesOptionals,
+      'queryParams' | 'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<
+          GetMetadataTaxonomyNodesOptionals,
+          'queryParams' | 'headers' | 'cancellationToken'
+        >
+      >,
+  ) {
+    if (fields.queryParams !== undefined) {
+      this.queryParams = fields.queryParams;
+    }
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface GetMetadataTaxonomyNodesOptionalsInput {
+  readonly queryParams?: GetMetadataTaxonomyNodesQueryParams;
+  readonly headers?: GetMetadataTaxonomyNodesHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class CreateMetadataTaxonomyNodeOptionals {
+  readonly headers: CreateMetadataTaxonomyNodeHeaders =
+    new CreateMetadataTaxonomyNodeHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      CreateMetadataTaxonomyNodeOptionals,
+      'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<
+          CreateMetadataTaxonomyNodeOptionals,
+          'headers' | 'cancellationToken'
+        >
+      >,
+  ) {
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface CreateMetadataTaxonomyNodeOptionalsInput {
+  readonly headers?: CreateMetadataTaxonomyNodeHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class GetMetadataTaxonomyNodeByIdOptionals {
+  readonly headers: GetMetadataTaxonomyNodeByIdHeaders =
+    new GetMetadataTaxonomyNodeByIdHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      GetMetadataTaxonomyNodeByIdOptionals,
+      'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<
+          GetMetadataTaxonomyNodeByIdOptionals,
+          'headers' | 'cancellationToken'
+        >
+      >,
+  ) {
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface GetMetadataTaxonomyNodeByIdOptionalsInput {
+  readonly headers?: GetMetadataTaxonomyNodeByIdHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class UpdateMetadataTaxonomyNodeOptionals {
+  readonly requestBody: UpdateMetadataTaxonomyNodeRequestBody =
+    {} satisfies UpdateMetadataTaxonomyNodeRequestBody;
+  readonly headers: UpdateMetadataTaxonomyNodeHeaders =
+    new UpdateMetadataTaxonomyNodeHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      UpdateMetadataTaxonomyNodeOptionals,
+      'requestBody' | 'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<
+          UpdateMetadataTaxonomyNodeOptionals,
+          'requestBody' | 'headers' | 'cancellationToken'
+        >
+      >,
+  ) {
+    if (fields.requestBody !== undefined) {
+      this.requestBody = fields.requestBody;
+    }
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface UpdateMetadataTaxonomyNodeOptionalsInput {
+  readonly requestBody?: UpdateMetadataTaxonomyNodeRequestBody;
+  readonly headers?: UpdateMetadataTaxonomyNodeHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class DeleteMetadataTaxonomyNodeOptionals {
+  readonly headers: DeleteMetadataTaxonomyNodeHeaders =
+    new DeleteMetadataTaxonomyNodeHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      DeleteMetadataTaxonomyNodeOptionals,
+      'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<
+          DeleteMetadataTaxonomyNodeOptionals,
+          'headers' | 'cancellationToken'
+        >
+      >,
+  ) {
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface DeleteMetadataTaxonomyNodeOptionalsInput {
+  readonly headers?: DeleteMetadataTaxonomyNodeHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export class GetMetadataTemplateFieldOptionsOptionals {
+  readonly queryParams: GetMetadataTemplateFieldOptionsQueryParams =
+    {} satisfies GetMetadataTemplateFieldOptionsQueryParams;
+  readonly headers: GetMetadataTemplateFieldOptionsHeaders =
+    new GetMetadataTemplateFieldOptionsHeaders({});
+  readonly cancellationToken?: CancellationToken = void 0;
+  constructor(
+    fields: Omit<
+      GetMetadataTemplateFieldOptionsOptionals,
+      'queryParams' | 'headers' | 'cancellationToken'
+    > &
+      Partial<
+        Pick<
+          GetMetadataTemplateFieldOptionsOptionals,
+          'queryParams' | 'headers' | 'cancellationToken'
+        >
+      >,
+  ) {
+    if (fields.queryParams !== undefined) {
+      this.queryParams = fields.queryParams;
+    }
+    if (fields.headers !== undefined) {
+      this.headers = fields.headers;
+    }
+    if (fields.cancellationToken !== undefined) {
+      this.cancellationToken = fields.cancellationToken;
+    }
+  }
+}
+export interface GetMetadataTemplateFieldOptionsOptionalsInput {
+  readonly queryParams?: GetMetadataTemplateFieldOptionsQueryParams;
+  readonly headers?: GetMetadataTemplateFieldOptionsHeaders;
+  readonly cancellationToken?: CancellationToken;
+}
+export interface CreateMetadataTaxonomyRequestBody {
+  /**
+   * The taxonomy key. If it is not provided in the request body, it will be
+   * generated from the `displayName`. The `displayName` would be converted
+   * to lower case, and all spaces and non-alphanumeric characters replaced
+   * with underscores. */
+  readonly key?: string;
+  /**
+   * The display name of the taxonomy. */
+  readonly displayName: string;
+  /**
+   * The namespace of the metadata taxonomy to create. */
+  readonly namespace: string;
+  readonly rawData?: SerializedData;
+}
+export class CreateMetadataTaxonomyHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<CreateMetadataTaxonomyHeaders, 'extraHeaders'> &
+      Partial<Pick<CreateMetadataTaxonomyHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface CreateMetadataTaxonomyHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export interface GetMetadataTaxonomiesQueryParams {
+  /**
+   * Defines the position marker at which to begin returning results. This is
+   * used when paginating using marker-based pagination.
+   *
+   * This requires `usemarker` to be set to `true`. */
+  readonly marker?: string;
+  /**
+   * The maximum number of items to return per page. */
+  readonly limit?: number;
+}
+export class GetMetadataTaxonomiesHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<GetMetadataTaxonomiesHeaders, 'extraHeaders'> &
+      Partial<Pick<GetMetadataTaxonomiesHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface GetMetadataTaxonomiesHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export class GetMetadataTaxonomyByKeyHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<GetMetadataTaxonomyByKeyHeaders, 'extraHeaders'> &
+      Partial<Pick<GetMetadataTaxonomyByKeyHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface GetMetadataTaxonomyByKeyHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export interface UpdateMetadataTaxonomyRequestBody {
+  /**
+   * The display name of the taxonomy. */
+  readonly displayName: string;
+  readonly rawData?: SerializedData;
+}
+export class UpdateMetadataTaxonomyHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<UpdateMetadataTaxonomyHeaders, 'extraHeaders'> &
+      Partial<Pick<UpdateMetadataTaxonomyHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface UpdateMetadataTaxonomyHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export class DeleteMetadataTaxonomyHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<DeleteMetadataTaxonomyHeaders, 'extraHeaders'> &
+      Partial<Pick<DeleteMetadataTaxonomyHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface DeleteMetadataTaxonomyHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export class CreateMetadataTaxonomyLevelHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<CreateMetadataTaxonomyLevelHeaders, 'extraHeaders'> &
+      Partial<Pick<CreateMetadataTaxonomyLevelHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface CreateMetadataTaxonomyLevelHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export interface UpdateMetadataTaxonomyLevelByIdRequestBody {
+  /**
+   * The display name of the taxonomy level. */
+  readonly displayName: string;
+  /**
+   * The description of the taxonomy level. */
+  readonly description?: string;
+  readonly rawData?: SerializedData;
+}
+export class UpdateMetadataTaxonomyLevelByIdHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<UpdateMetadataTaxonomyLevelByIdHeaders, 'extraHeaders'> &
+      Partial<Pick<UpdateMetadataTaxonomyLevelByIdHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface UpdateMetadataTaxonomyLevelByIdHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export interface AddMetadataTaxonomyLevelRequestBody {
+  /**
+   * The display name of the taxonomy level. */
+  readonly displayName: string;
+  /**
+   * The description of the taxonomy level. */
+  readonly description?: string;
+  readonly rawData?: SerializedData;
+}
+export class AddMetadataTaxonomyLevelHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<AddMetadataTaxonomyLevelHeaders, 'extraHeaders'> &
+      Partial<Pick<AddMetadataTaxonomyLevelHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface AddMetadataTaxonomyLevelHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export class DeleteMetadataTaxonomyLevelHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<DeleteMetadataTaxonomyLevelHeaders, 'extraHeaders'> &
+      Partial<Pick<DeleteMetadataTaxonomyLevelHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface DeleteMetadataTaxonomyLevelHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export interface GetMetadataTaxonomyNodesQueryParams {
+  /**
+   * Filters results by taxonomy level. Multiple values can be provided.
+   * Results include nodes that match any of the specified values. */
+  readonly level?: readonly number[];
+  /**
+   * Node identifier of a direct parent node. Multiple values can be provided.
+   * Results include nodes that match any of the specified values. */
+  readonly parent?: readonly string[];
+  /**
+   * Node identifier of any ancestor node. Multiple values can be provided.
+   * Results include nodes that match any of the specified values. */
+  readonly ancestor?: readonly string[];
+  /**
+   * Query text to search for the taxonomy nodes. */
+  readonly query?: string;
+  /**
+   * When set to `true` this provides the total number of nodes that matched the query.
+   * The response will compute counts of up to 10,000 elements. Defaults to `false`. */
+  readonly includeTotalResultCount?: boolean;
+  /**
+   * Defines the position marker at which to begin returning results. This is
+   * used when paginating using marker-based pagination.
+   *
+   * This requires `usemarker` to be set to `true`. */
+  readonly marker?: string;
+  /**
+   * The maximum number of items to return per page. */
+  readonly limit?: number;
+}
+export class GetMetadataTaxonomyNodesHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<GetMetadataTaxonomyNodesHeaders, 'extraHeaders'> &
+      Partial<Pick<GetMetadataTaxonomyNodesHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface GetMetadataTaxonomyNodesHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export interface CreateMetadataTaxonomyNodeRequestBody {
+  /**
+   * The display name of the taxonomy node. */
+  readonly displayName: string;
+  /**
+   * The level of the taxonomy node. */
+  readonly level: number;
+  /**
+   * The identifier of the parent taxonomy node.
+   * Omit this field for root-level nodes. */
+  readonly parentId?: string;
+  readonly rawData?: SerializedData;
+}
+export class CreateMetadataTaxonomyNodeHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<CreateMetadataTaxonomyNodeHeaders, 'extraHeaders'> &
+      Partial<Pick<CreateMetadataTaxonomyNodeHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface CreateMetadataTaxonomyNodeHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export class GetMetadataTaxonomyNodeByIdHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<GetMetadataTaxonomyNodeByIdHeaders, 'extraHeaders'> &
+      Partial<Pick<GetMetadataTaxonomyNodeByIdHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface GetMetadataTaxonomyNodeByIdHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export interface UpdateMetadataTaxonomyNodeRequestBody {
+  /**
+   * The display name of the taxonomy node. */
+  readonly displayName?: string;
+  readonly rawData?: SerializedData;
+}
+export class UpdateMetadataTaxonomyNodeHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<UpdateMetadataTaxonomyNodeHeaders, 'extraHeaders'> &
+      Partial<Pick<UpdateMetadataTaxonomyNodeHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface UpdateMetadataTaxonomyNodeHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export class DeleteMetadataTaxonomyNodeHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<DeleteMetadataTaxonomyNodeHeaders, 'extraHeaders'> &
+      Partial<Pick<DeleteMetadataTaxonomyNodeHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface DeleteMetadataTaxonomyNodeHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export interface GetMetadataTemplateFieldOptionsQueryParams {
+  /**
+   * Filters results by taxonomy level. Multiple values can be provided.
+   * Results include nodes that match any of the specified values. */
+  readonly level?: readonly number[];
+  /**
+   * Node identifier of a direct parent node. Multiple values can be provided.
+   * Results include nodes that match any of the specified values. */
+  readonly parent?: readonly string[];
+  /**
+   * Node identifier of any ancestor node. Multiple values can be provided.
+   * Results include nodes that match any of the specified values. */
+  readonly ancestor?: readonly string[];
+  /**
+   * Query text to search for the taxonomy nodes. */
+  readonly query?: string;
+  /**
+   * When set to `true` this provides the total number of nodes that matched the query.
+   * The response will compute counts of up to 10,000 elements. Defaults to `false`. */
+  readonly includeTotalResultCount?: boolean;
+  /**
+   * When set to `true`, this only returns valid selectable options for this template
+   * taxonomy field. Otherwise, it returns all taxonomy nodes, whether or not they are selectable.
+   * Defaults to `true`. */
+  readonly onlySelectableOptions?: boolean;
+  /**
+   * Defines the position marker at which to begin returning results. This is
+   * used when paginating using marker-based pagination.
+   *
+   * This requires `usemarker` to be set to `true`. */
+  readonly marker?: string;
+  /**
+   * The maximum number of items to return per page. */
+  readonly limit?: number;
+}
+export class GetMetadataTemplateFieldOptionsHeaders {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  } = {};
+  constructor(
+    fields: Omit<GetMetadataTemplateFieldOptionsHeaders, 'extraHeaders'> &
+      Partial<Pick<GetMetadataTemplateFieldOptionsHeaders, 'extraHeaders'>>,
+  ) {
+    if (fields.extraHeaders !== undefined) {
+      this.extraHeaders = fields.extraHeaders;
+    }
+  }
+}
+export interface GetMetadataTemplateFieldOptionsHeadersInput {
+  /**
+   * Extra headers that will be included in the HTTP request. */
+  readonly extraHeaders?: {
+    readonly [key: string]: undefined | string;
+  };
+}
+export class MetadataTaxonomiesManager {
+  readonly auth?: Authentication;
+  readonly networkSession: NetworkSession = new NetworkSession({});
+  constructor(
+    fields: Omit<
+      MetadataTaxonomiesManager,
+      | 'networkSession'
+      | 'createMetadataTaxonomy'
+      | 'getMetadataTaxonomies'
+      | 'getMetadataTaxonomyByKey'
+      | 'updateMetadataTaxonomy'
+      | 'deleteMetadataTaxonomy'
+      | 'createMetadataTaxonomyLevel'
+      | 'updateMetadataTaxonomyLevelById'
+      | 'addMetadataTaxonomyLevel'
+      | 'deleteMetadataTaxonomyLevel'
+      | 'getMetadataTaxonomyNodes'
+      | 'createMetadataTaxonomyNode'
+      | 'getMetadataTaxonomyNodeById'
+      | 'updateMetadataTaxonomyNode'
+      | 'deleteMetadataTaxonomyNode'
+      | 'getMetadataTemplateFieldOptions'
+    > &
+      Partial<Pick<MetadataTaxonomiesManager, 'networkSession'>>,
+  ) {
+    if (fields.auth !== undefined) {
+      this.auth = fields.auth;
+    }
+    if (fields.networkSession !== undefined) {
+      this.networkSession = fields.networkSession;
+    }
+  }
+  /**
+   * Creates a new metadata taxonomy that can be used in
+   * metadata templates.
+   * @param {CreateMetadataTaxonomyRequestBody} requestBody Request body of createMetadataTaxonomy method
+   * @param {CreateMetadataTaxonomyOptionalsInput} optionalsInput
+   * @returns {Promise<MetadataTaxonomy>}
+   */
+  async createMetadataTaxonomy(
+    requestBody: CreateMetadataTaxonomyRequestBody,
+    optionalsInput: CreateMetadataTaxonomyOptionalsInput = {},
+  ): Promise<MetadataTaxonomy> {
+    const optionals: CreateMetadataTaxonomyOptionals =
+      new CreateMetadataTaxonomyOptionals({
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies',
+          ) as string,
+          method: 'POST',
+          headers: headersMap,
+          data: serializeCreateMetadataTaxonomyRequestBody(requestBody),
+          contentType: 'application/json',
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomy(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Used to retrieve all metadata taxonomies in a namespace.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {GetMetadataTaxonomiesOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomies>}
+     */
+  async getMetadataTaxonomies(
+    namespace: string,
+    optionalsInput: GetMetadataTaxonomiesOptionalsInput = {},
+  ): Promise<MetadataTaxonomies> {
+    const optionals: GetMetadataTaxonomiesOptionals =
+      new GetMetadataTaxonomiesOptionals({
+        queryParams: optionalsInput.queryParams,
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const queryParams: any = optionals.queryParams;
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const queryParamsMap: {
+      readonly [key: string]: string;
+    } = prepareParams({
+      ['marker']: toString(queryParams.marker) as string,
+      ['limit']: toString(queryParams.limit) as string,
+    });
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+          ) as string,
+          method: 'GET',
+          params: queryParamsMap,
+          headers: headersMap,
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomies(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Used to retrieve a metadata taxonomy by taxonomy key.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {GetMetadataTaxonomyByKeyOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomy>}
+     */
+  async getMetadataTaxonomyByKey(
+    namespace: string,
+    taxonomyKey: string,
+    optionalsInput: GetMetadataTaxonomyByKeyOptionalsInput = {},
+  ): Promise<MetadataTaxonomy> {
+    const optionals: GetMetadataTaxonomyByKeyOptionals =
+      new GetMetadataTaxonomyByKeyOptionals({
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+          ) as string,
+          method: 'GET',
+          headers: headersMap,
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomy(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Updates an existing metadata taxonomy.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {UpdateMetadataTaxonomyRequestBody} requestBody Request body of updateMetadataTaxonomy method
+     * @param {UpdateMetadataTaxonomyOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomy>}
+     */
+  async updateMetadataTaxonomy(
+    namespace: string,
+    taxonomyKey: string,
+    requestBody: UpdateMetadataTaxonomyRequestBody,
+    optionalsInput: UpdateMetadataTaxonomyOptionalsInput = {},
+  ): Promise<MetadataTaxonomy> {
+    const optionals: UpdateMetadataTaxonomyOptionals =
+      new UpdateMetadataTaxonomyOptionals({
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+          ) as string,
+          method: 'PATCH',
+          headers: headersMap,
+          data: serializeUpdateMetadataTaxonomyRequestBody(requestBody),
+          contentType: 'application/json',
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomy(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Delete a metadata taxonomy.
+     * This deletion is permanent and cannot be reverted.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {DeleteMetadataTaxonomyOptionalsInput} optionalsInput
+     * @returns {Promise<undefined>}
+     */
+  async deleteMetadataTaxonomy(
+    namespace: string,
+    taxonomyKey: string,
+    optionalsInput: DeleteMetadataTaxonomyOptionalsInput = {},
+  ): Promise<undefined> {
+    const optionals: DeleteMetadataTaxonomyOptionals =
+      new DeleteMetadataTaxonomyOptionals({
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+          ) as string,
+          method: 'DELETE',
+          headers: headersMap,
+          responseFormat: 'no_content' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return void 0;
+  }
+  /**
+     * Creates new metadata taxonomy levels.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {readonly MetadataTaxonomyLevel[]} requestBody Request body of createMetadataTaxonomyLevel method
+     * @param {CreateMetadataTaxonomyLevelOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomyLevels>}
+     */
+  async createMetadataTaxonomyLevel(
+    namespace: string,
+    taxonomyKey: string,
+    requestBody: readonly MetadataTaxonomyLevel[],
+    optionalsInput: CreateMetadataTaxonomyLevelOptionalsInput = {},
+  ): Promise<MetadataTaxonomyLevels> {
+    const optionals: CreateMetadataTaxonomyLevelOptionals =
+      new CreateMetadataTaxonomyLevelOptionals({
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+            '/levels',
+          ) as string,
+          method: 'POST',
+          headers: headersMap,
+          data: requestBody.map(
+            serializeMetadataTaxonomyLevel,
+          ) as readonly any[],
+          contentType: 'application/json',
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomyLevels(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Updates an existing metadata taxonomy level.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {number} levelIndex The index of the metadata taxonomy level.
+    Example: 1
+     * @param {UpdateMetadataTaxonomyLevelByIdRequestBody} requestBody Request body of updateMetadataTaxonomyLevelById method
+     * @param {UpdateMetadataTaxonomyLevelByIdOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomyLevel>}
+     */
+  async updateMetadataTaxonomyLevelById(
+    namespace: string,
+    taxonomyKey: string,
+    levelIndex: number,
+    requestBody: UpdateMetadataTaxonomyLevelByIdRequestBody,
+    optionalsInput: UpdateMetadataTaxonomyLevelByIdOptionalsInput = {},
+  ): Promise<MetadataTaxonomyLevel> {
+    const optionals: UpdateMetadataTaxonomyLevelByIdOptionals =
+      new UpdateMetadataTaxonomyLevelByIdOptionals({
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+            '/levels/',
+            (toString(levelIndex) as string)!,
+          ) as string,
+          method: 'PATCH',
+          headers: headersMap,
+          data: serializeUpdateMetadataTaxonomyLevelByIdRequestBody(
+            requestBody,
+          ),
+          contentType: 'application/json',
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomyLevel(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Creates a new metadata taxonomy level and appends it to the existing levels.
+     * If there are no levels defined yet, this will create the first level.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {AddMetadataTaxonomyLevelRequestBody} requestBody Request body of addMetadataTaxonomyLevel method
+     * @param {AddMetadataTaxonomyLevelOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomyLevels>}
+     */
+  async addMetadataTaxonomyLevel(
+    namespace: string,
+    taxonomyKey: string,
+    requestBody: AddMetadataTaxonomyLevelRequestBody,
+    optionalsInput: AddMetadataTaxonomyLevelOptionalsInput = {},
+  ): Promise<MetadataTaxonomyLevels> {
+    const optionals: AddMetadataTaxonomyLevelOptionals =
+      new AddMetadataTaxonomyLevelOptionals({
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+            '/levels:append',
+          ) as string,
+          method: 'POST',
+          headers: headersMap,
+          data: serializeAddMetadataTaxonomyLevelRequestBody(requestBody),
+          contentType: 'application/json',
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomyLevels(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Deletes the last level of the metadata taxonomy.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {DeleteMetadataTaxonomyLevelOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomyLevels>}
+     */
+  async deleteMetadataTaxonomyLevel(
+    namespace: string,
+    taxonomyKey: string,
+    optionalsInput: DeleteMetadataTaxonomyLevelOptionalsInput = {},
+  ): Promise<MetadataTaxonomyLevels> {
+    const optionals: DeleteMetadataTaxonomyLevelOptionals =
+      new DeleteMetadataTaxonomyLevelOptionals({
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+            '/levels:trim',
+          ) as string,
+          method: 'POST',
+          headers: headersMap,
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomyLevels(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Used to retrieve metadata taxonomy nodes based on the parameters specified.
+     * Results are sorted in lexicographic order unless a `query` parameter is passed.
+     * With a `query` parameter specified, results are sorted in order of relevance.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {GetMetadataTaxonomyNodesOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomyNodes>}
+     */
+  async getMetadataTaxonomyNodes(
+    namespace: string,
+    taxonomyKey: string,
+    optionalsInput: GetMetadataTaxonomyNodesOptionalsInput = {},
+  ): Promise<MetadataTaxonomyNodes> {
+    const optionals: GetMetadataTaxonomyNodesOptionals =
+      new GetMetadataTaxonomyNodesOptionals({
+        queryParams: optionalsInput.queryParams,
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const queryParams: any = optionals.queryParams;
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const queryParamsMap: {
+      readonly [key: string]: string;
+    } = prepareParams({
+      ['level']: queryParams.level
+        ? queryParams.level.map(toString).join(',')
+        : undefined,
+      ['parent']: queryParams.parent
+        ? queryParams.parent.map(toString).join(',')
+        : undefined,
+      ['ancestor']: queryParams.ancestor
+        ? queryParams.ancestor.map(toString).join(',')
+        : undefined,
+      ['query']: toString(queryParams.query) as string,
+      ['include-total-result-count']: toString(
+        queryParams.includeTotalResultCount,
+      ) as string,
+      ['marker']: toString(queryParams.marker) as string,
+      ['limit']: toString(queryParams.limit) as string,
+    });
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+            '/nodes',
+          ) as string,
+          method: 'GET',
+          params: queryParamsMap,
+          headers: headersMap,
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomyNodes(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Creates a new metadata taxonomy node.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {CreateMetadataTaxonomyNodeRequestBody} requestBody Request body of createMetadataTaxonomyNode method
+     * @param {CreateMetadataTaxonomyNodeOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomyNode>}
+     */
+  async createMetadataTaxonomyNode(
+    namespace: string,
+    taxonomyKey: string,
+    requestBody: CreateMetadataTaxonomyNodeRequestBody,
+    optionalsInput: CreateMetadataTaxonomyNodeOptionalsInput = {},
+  ): Promise<MetadataTaxonomyNode> {
+    const optionals: CreateMetadataTaxonomyNodeOptionals =
+      new CreateMetadataTaxonomyNodeOptionals({
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+            '/nodes',
+          ) as string,
+          method: 'POST',
+          headers: headersMap,
+          data: serializeCreateMetadataTaxonomyNodeRequestBody(requestBody),
+          contentType: 'application/json',
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomyNode(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Retrieves a metadata taxonomy node by its identifier.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {string} nodeId The identifier of the metadata taxonomy node.
+    Example: "14d3d433-c77f-49c5-b146-9dea370f6e32"
+     * @param {GetMetadataTaxonomyNodeByIdOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomyNode>}
+     */
+  async getMetadataTaxonomyNodeById(
+    namespace: string,
+    taxonomyKey: string,
+    nodeId: string,
+    optionalsInput: GetMetadataTaxonomyNodeByIdOptionalsInput = {},
+  ): Promise<MetadataTaxonomyNode> {
+    const optionals: GetMetadataTaxonomyNodeByIdOptionals =
+      new GetMetadataTaxonomyNodeByIdOptionals({
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+            '/nodes/',
+            (toString(nodeId) as string)!,
+          ) as string,
+          method: 'GET',
+          headers: headersMap,
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomyNode(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Updates an existing metadata taxonomy node.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {string} nodeId The identifier of the metadata taxonomy node.
+    Example: "14d3d433-c77f-49c5-b146-9dea370f6e32"
+     * @param {UpdateMetadataTaxonomyNodeOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomyNode>}
+     */
+  async updateMetadataTaxonomyNode(
+    namespace: string,
+    taxonomyKey: string,
+    nodeId: string,
+    optionalsInput: UpdateMetadataTaxonomyNodeOptionalsInput = {},
+  ): Promise<MetadataTaxonomyNode> {
+    const optionals: UpdateMetadataTaxonomyNodeOptionals =
+      new UpdateMetadataTaxonomyNodeOptionals({
+        requestBody: optionalsInput.requestBody,
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const requestBody: any = optionals.requestBody;
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+            '/nodes/',
+            (toString(nodeId) as string)!,
+          ) as string,
+          method: 'PATCH',
+          headers: headersMap,
+          data: serializeUpdateMetadataTaxonomyNodeRequestBody(requestBody),
+          contentType: 'application/json',
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomyNode(response.data!),
+      rawData: response.data!,
+    };
+  }
+  /**
+     * Delete a metadata taxonomy node.
+     * This deletion is permanent and cannot be reverted.
+     * Only metadata taxonomy nodes without any children can be deleted.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} taxonomyKey The key of the metadata taxonomy.
+    Example: "geography"
+     * @param {string} nodeId The identifier of the metadata taxonomy node.
+    Example: "14d3d433-c77f-49c5-b146-9dea370f6e32"
+     * @param {DeleteMetadataTaxonomyNodeOptionalsInput} optionalsInput
+     * @returns {Promise<undefined>}
+     */
+  async deleteMetadataTaxonomyNode(
+    namespace: string,
+    taxonomyKey: string,
+    nodeId: string,
+    optionalsInput: DeleteMetadataTaxonomyNodeOptionalsInput = {},
+  ): Promise<undefined> {
+    const optionals: DeleteMetadataTaxonomyNodeOptionals =
+      new DeleteMetadataTaxonomyNodeOptionals({
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_taxonomies/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(taxonomyKey) as string)!,
+            '/nodes/',
+            (toString(nodeId) as string)!,
+          ) as string,
+          method: 'DELETE',
+          headers: headersMap,
+          responseFormat: 'no_content' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return void 0;
+  }
+  /**
+     * Used to retrieve metadata taxonomy nodes which are available for the taxonomy field based
+     * on its configuration and the parameters specified.
+     * Results are sorted in lexicographic order unless a `query` parameter is passed.
+     * With a `query` parameter specified, results are sorted in order of relevance.
+     * @param {string} namespace The namespace of the metadata taxonomy.
+    Example: "enterprise_123456"
+     * @param {string} templateKey The name of the metadata template.
+    Example: "properties"
+     * @param {string} fieldKey The key of the metadata taxonomy field in the template.
+    Example: "geography"
+     * @param {GetMetadataTemplateFieldOptionsOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomyNodes>}
+     */
+  async getMetadataTemplateFieldOptions(
+    namespace: string,
+    templateKey: string,
+    fieldKey: string,
+    optionalsInput: GetMetadataTemplateFieldOptionsOptionalsInput = {},
+  ): Promise<MetadataTaxonomyNodes> {
+    const optionals: GetMetadataTemplateFieldOptionsOptionals =
+      new GetMetadataTemplateFieldOptionsOptionals({
+        queryParams: optionalsInput.queryParams,
+        headers: optionalsInput.headers,
+        cancellationToken: optionalsInput.cancellationToken,
+      });
+    const queryParams: any = optionals.queryParams;
+    const headers: any = optionals.headers;
+    const cancellationToken: any = optionals.cancellationToken;
+    const queryParamsMap: {
+      readonly [key: string]: string;
+    } = prepareParams({
+      ['level']: queryParams.level
+        ? queryParams.level.map(toString).join(',')
+        : undefined,
+      ['parent']: queryParams.parent
+        ? queryParams.parent.map(toString).join(',')
+        : undefined,
+      ['ancestor']: queryParams.ancestor
+        ? queryParams.ancestor.map(toString).join(',')
+        : undefined,
+      ['query']: toString(queryParams.query) as string,
+      ['include-total-result-count']: toString(
+        queryParams.includeTotalResultCount,
+      ) as string,
+      ['only-selectable-options']: toString(
+        queryParams.onlySelectableOptions,
+      ) as string,
+      ['marker']: toString(queryParams.marker) as string,
+      ['limit']: toString(queryParams.limit) as string,
+    });
+    const headersMap: {
+      readonly [key: string]: string;
+    } = prepareParams({ ...{}, ...headers.extraHeaders });
+    const response: FetchResponse =
+      await this.networkSession.networkClient.fetch(
+        new FetchOptions({
+          url: ''.concat(
+            this.networkSession.baseUrls.baseUrl,
+            '/2.0/metadata_templates/',
+            (toString(namespace) as string)!,
+            '/',
+            (toString(templateKey) as string)!,
+            '/fields/',
+            (toString(fieldKey) as string)!,
+            '/options',
+          ) as string,
+          method: 'GET',
+          params: queryParamsMap,
+          headers: headersMap,
+          responseFormat: 'json' as ResponseFormat,
+          auth: this.auth,
+          networkSession: this.networkSession,
+          cancellationToken: cancellationToken,
+        }),
+      );
+    return {
+      ...deserializeMetadataTaxonomyNodes(response.data!),
+      rawData: response.data!,
+    };
+  }
+}
+export interface MetadataTaxonomiesManagerInput {
+  readonly auth?: Authentication;
+  readonly networkSession?: NetworkSession;
+}
+export function serializeCreateMetadataTaxonomyRequestBody(
+  val: CreateMetadataTaxonomyRequestBody,
+): SerializedData {
+  return {
+    ['key']: val.key,
+    ['displayName']: val.displayName,
+    ['namespace']: val.namespace,
+  };
+}
+export function deserializeCreateMetadataTaxonomyRequestBody(
+  val: SerializedData,
+): CreateMetadataTaxonomyRequestBody {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "CreateMetadataTaxonomyRequestBody"',
+    });
+  }
+  if (!(val.key == void 0) && !sdIsString(val.key)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "key" of type "CreateMetadataTaxonomyRequestBody"',
+    });
+  }
+  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 "CreateMetadataTaxonomyRequestBody" to be defined',
+    });
+  }
+  if (!sdIsString(val.displayName)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "displayName" of type "CreateMetadataTaxonomyRequestBody"',
+    });
+  }
+  const displayName: string = val.displayName;
+  if (val.namespace == void 0) {
+    throw new BoxSdkError({
+      message:
+        'Expecting "namespace" of type "CreateMetadataTaxonomyRequestBody" to be defined',
+    });
+  }
+  if (!sdIsString(val.namespace)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "namespace" of type "CreateMetadataTaxonomyRequestBody"',
+    });
+  }
+  const namespace: string = val.namespace;
+  return {
+    key: key,
+    displayName: displayName,
+    namespace: namespace,
+  } satisfies CreateMetadataTaxonomyRequestBody;
+}
+export function serializeUpdateMetadataTaxonomyRequestBody(
+  val: UpdateMetadataTaxonomyRequestBody,
+): SerializedData {
+  return { ['displayName']: val.displayName };
+}
+export function deserializeUpdateMetadataTaxonomyRequestBody(
+  val: SerializedData,
+): UpdateMetadataTaxonomyRequestBody {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "UpdateMetadataTaxonomyRequestBody"',
+    });
+  }
+  if (val.displayName == void 0) {
+    throw new BoxSdkError({
+      message:
+        'Expecting "displayName" of type "UpdateMetadataTaxonomyRequestBody" to be defined',
+    });
+  }
+  if (!sdIsString(val.displayName)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "displayName" of type "UpdateMetadataTaxonomyRequestBody"',
+    });
+  }
+  const displayName: string = val.displayName;
+  return {
+    displayName: displayName,
+  } satisfies UpdateMetadataTaxonomyRequestBody;
+}
+export function serializeUpdateMetadataTaxonomyLevelByIdRequestBody(
+  val: UpdateMetadataTaxonomyLevelByIdRequestBody,
+): SerializedData {
+  return { ['displayName']: val.displayName, ['description']: val.description };
+}
+export function deserializeUpdateMetadataTaxonomyLevelByIdRequestBody(
+  val: SerializedData,
+): UpdateMetadataTaxonomyLevelByIdRequestBody {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting a map for "UpdateMetadataTaxonomyLevelByIdRequestBody"',
+    });
+  }
+  if (val.displayName == void 0) {
+    throw new BoxSdkError({
+      message:
+        'Expecting "displayName" of type "UpdateMetadataTaxonomyLevelByIdRequestBody" to be defined',
+    });
+  }
+  if (!sdIsString(val.displayName)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "displayName" of type "UpdateMetadataTaxonomyLevelByIdRequestBody"',
+    });
+  }
+  const displayName: string = val.displayName;
+  if (!(val.description == void 0) && !sdIsString(val.description)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "description" of type "UpdateMetadataTaxonomyLevelByIdRequestBody"',
+    });
+  }
+  const description: undefined | string =
+    val.description == void 0 ? void 0 : val.description;
+  return {
+    displayName: displayName,
+    description: description,
+  } satisfies UpdateMetadataTaxonomyLevelByIdRequestBody;
+}
+export function serializeAddMetadataTaxonomyLevelRequestBody(
+  val: AddMetadataTaxonomyLevelRequestBody,
+): SerializedData {
+  return { ['displayName']: val.displayName, ['description']: val.description };
+}
+export function deserializeAddMetadataTaxonomyLevelRequestBody(
+  val: SerializedData,
+): AddMetadataTaxonomyLevelRequestBody {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "AddMetadataTaxonomyLevelRequestBody"',
+    });
+  }
+  if (val.displayName == void 0) {
+    throw new BoxSdkError({
+      message:
+        'Expecting "displayName" of type "AddMetadataTaxonomyLevelRequestBody" to be defined',
+    });
+  }
+  if (!sdIsString(val.displayName)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "displayName" of type "AddMetadataTaxonomyLevelRequestBody"',
+    });
+  }
+  const displayName: string = val.displayName;
+  if (!(val.description == void 0) && !sdIsString(val.description)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "description" of type "AddMetadataTaxonomyLevelRequestBody"',
+    });
+  }
+  const description: undefined | string =
+    val.description == void 0 ? void 0 : val.description;
+  return {
+    displayName: displayName,
+    description: description,
+  } satisfies AddMetadataTaxonomyLevelRequestBody;
+}
+export function serializeCreateMetadataTaxonomyNodeRequestBody(
+  val: CreateMetadataTaxonomyNodeRequestBody,
+): SerializedData {
+  return {
+    ['displayName']: val.displayName,
+    ['level']: val.level,
+    ['parentId']: val.parentId,
+  };
+}
+export function deserializeCreateMetadataTaxonomyNodeRequestBody(
+  val: SerializedData,
+): CreateMetadataTaxonomyNodeRequestBody {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "CreateMetadataTaxonomyNodeRequestBody"',
+    });
+  }
+  if (val.displayName == void 0) {
+    throw new BoxSdkError({
+      message:
+        'Expecting "displayName" of type "CreateMetadataTaxonomyNodeRequestBody" to be defined',
+    });
+  }
+  if (!sdIsString(val.displayName)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "displayName" of type "CreateMetadataTaxonomyNodeRequestBody"',
+    });
+  }
+  const displayName: string = val.displayName;
+  if (val.level == void 0) {
+    throw new BoxSdkError({
+      message:
+        'Expecting "level" of type "CreateMetadataTaxonomyNodeRequestBody" to be defined',
+    });
+  }
+  if (!sdIsNumber(val.level)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting number for "level" of type "CreateMetadataTaxonomyNodeRequestBody"',
+    });
+  }
+  const level: number = val.level;
+  if (!(val.parentId == void 0) && !sdIsString(val.parentId)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "parentId" of type "CreateMetadataTaxonomyNodeRequestBody"',
+    });
+  }
+  const parentId: undefined | string =
+    val.parentId == void 0 ? void 0 : val.parentId;
+  return {
+    displayName: displayName,
+    level: level,
+    parentId: parentId,
+  } satisfies CreateMetadataTaxonomyNodeRequestBody;
+}
+export function serializeUpdateMetadataTaxonomyNodeRequestBody(
+  val: UpdateMetadataTaxonomyNodeRequestBody,
+): SerializedData {
+  return { ['displayName']: val.displayName };
+}
+export function deserializeUpdateMetadataTaxonomyNodeRequestBody(
+  val: SerializedData,
+): UpdateMetadataTaxonomyNodeRequestBody {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "UpdateMetadataTaxonomyNodeRequestBody"',
+    });
+  }
+  if (!(val.displayName == void 0) && !sdIsString(val.displayName)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "displayName" of type "UpdateMetadataTaxonomyNodeRequestBody"',
+    });
+  }
+  const displayName: undefined | string =
+    val.displayName == void 0 ? void 0 : val.displayName;
+  return {
+    displayName: displayName,
+  } satisfies UpdateMetadataTaxonomyNodeRequestBody;
+}