box-node-sdk 4.2.0 → 4.3.0

package/lib-esm/bundle.js

@@ -3622,7 +3622,7 @@
     var browserExports = browser.exports;
     var nodeFetch = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
-    const sdkVersion = '4.2.0';
+    const sdkVersion = '4.3.0';
 
     class BoxRetryStrategy {
         constructor(fields) {
@@ -3688,7 +3688,9 @@
          * @returns {number}
          */
         retryAfter(fetchOptions, fetchResponse, attemptNumber) {
-            const retryAfterHeader = fetchResponse.headers['Retry-After'];
+            const retryAfterHeader = 'Retry-After' in fetchResponse.headers
+                ? fetchResponse.headers['Retry-After']
+                : void 0;
             if (!(retryAfterHeader == void 0)) {
                 return parseFloat(retryAfterHeader);
             }
@@ -8443,10 +8445,10 @@
            * trash can it be retrieved with this API call. If instead one of
            * its parent folders was moved to the trash, only that folder
            * can be inspected using the
-           * [`GET /folders/:id/trash`](e://get_folders_id_trash) API.
+           * [`GET /folders/:id/trash`](https://developer.box.com/reference/get-folders-id-trash) API.
            *
            * To list all items that have been moved to the trash, please
-           * use the [`GET /folders/trash/items`](e://get-folders-trash-items/)
+           * use the [`GET /folders/trash/items`](https://developer.box.com/reference/get-folders-trash-items/)
            * API.
            * @param {string} fileId The unique identifier that represents a file.
           
@@ -10096,7 +10098,7 @@
          * This allows to always upload your content to the closest Box data center and can significantly improve upload speed.
          *  Return information about an upload session.
          *
-         * The actual endpoint URL is returned by the [`Create upload session`](e://post-files-upload-sessions) endpoint.
+         * The actual endpoint URL is returned by the [`Create upload session`](https://developer.box.com/reference/post-files-upload-sessions) endpoint.
          * @param {string} url URL of getFileUploadSessionById method
          * @param {GetFileUploadSessionByUrlOptionalsInput} optionalsInput
          * @returns {Promise<UploadSession>}
@@ -10125,7 +10127,7 @@
         /**
            * Return information about an upload session.
            *
-           * The actual endpoint URL is returned by the [`Create upload session`](e://post-files-upload-sessions) endpoint.
+           * The actual endpoint URL is returned by the [`Create upload session`](https://developer.box.com/reference/post-files-upload-sessions) endpoint.
            * @param {string} uploadSessionId The ID of the upload session.
           Example: "D5E3F7A"
            * @param {GetFileUploadSessionByIdOptionalsInput} optionalsInput
@@ -10157,8 +10159,8 @@
          * This allows to always upload your content to the closest Box data center and can significantly improve upload speed.
          *  Uploads a chunk of a file for an upload session.
          *
-         * The actual endpoint URL is returned by the [`Create upload session`](e://post-files-upload-sessions)
-         * and [`Get upload session`](e://get-files-upload-sessions-id) endpoints.
+         * The actual endpoint URL is returned by the [`Create upload session`](https://developer.box.com/reference/post-files-upload-sessions)
+         * and [`Get upload session`](https://developer.box.com/reference/get-files-upload-sessions-id) endpoints.
          * @param {string} url URL of uploadFilePart method
          * @param {ByteStream} requestBody Request body of uploadFilePart method
          * @param {UploadFilePartByUrlHeadersInput} headersInput Headers of uploadFilePart method
@@ -10197,8 +10199,8 @@
         /**
            * Uploads a chunk of a file for an upload session.
            *
-           * The actual endpoint URL is returned by the [`Create upload session`](e://post-files-upload-sessions)
-           * and [`Get upload session`](e://get-files-upload-sessions-id) endpoints.
+           * The actual endpoint URL is returned by the [`Create upload session`](https://developer.box.com/reference/post-files-upload-sessions)
+           * and [`Get upload session`](https://developer.box.com/reference/get-files-upload-sessions-id) endpoints.
            * @param {string} uploadSessionId The ID of the upload session.
           Example: "D5E3F7A"
            * @param {ByteStream} requestBody Request body of uploadFilePart method
@@ -10242,8 +10244,8 @@
          *
          * This cannot be reversed.
          *
-         * The actual endpoint URL is returned by the [`Create upload session`](e://post-files-upload-sessions)
-         * and [`Get upload session`](e://get-files-upload-sessions-id) endpoints.
+         * The actual endpoint URL is returned by the [`Create upload session`](https://developer.box.com/reference/post-files-upload-sessions)
+         * and [`Get upload session`](https://developer.box.com/reference/get-files-upload-sessions-id) endpoints.
          * @param {string} url URL of deleteFileUploadSessionById method
          * @param {DeleteFileUploadSessionByUrlOptionalsInput} optionalsInput
          * @returns {Promise<undefined>}
@@ -10274,8 +10276,8 @@
            *
            * This cannot be reversed.
            *
-           * The actual endpoint URL is returned by the [`Create upload session`](e://post-files-upload-sessions)
-           * and [`Get upload session`](e://get-files-upload-sessions-id) endpoints.
+           * The actual endpoint URL is returned by the [`Create upload session`](https://developer.box.com/reference/post-files-upload-sessions)
+           * and [`Get upload session`](https://developer.box.com/reference/get-files-upload-sessions-id) endpoints.
            * @param {string} uploadSessionId The ID of the upload session.
           Example: "D5E3F7A"
            * @param {DeleteFileUploadSessionByIdOptionalsInput} optionalsInput
@@ -10307,8 +10309,8 @@
          * This allows to always upload your content to the closest Box data center and can significantly improve upload speed.
          *  Return a list of the chunks uploaded to the upload session so far.
          *
-         * The actual endpoint URL is returned by the [`Create upload session`](e://post-files-upload-sessions)
-         * and [`Get upload session`](e://get-files-upload-sessions-id) endpoints.
+         * The actual endpoint URL is returned by the [`Create upload session`](https://developer.box.com/reference/post-files-upload-sessions)
+         * and [`Get upload session`](https://developer.box.com/reference/get-files-upload-sessions-id) endpoints.
          * @param {string} url URL of getFileUploadSessionParts method
          * @param {GetFileUploadSessionPartsByUrlOptionalsInput} optionalsInput
          * @returns {Promise<UploadParts>}
@@ -10344,8 +10346,8 @@
         /**
            * Return a list of the chunks uploaded to the upload session so far.
            *
-           * The actual endpoint URL is returned by the [`Create upload session`](e://post-files-upload-sessions)
-           * and [`Get upload session`](e://get-files-upload-sessions-id) endpoints.
+           * The actual endpoint URL is returned by the [`Create upload session`](https://developer.box.com/reference/post-files-upload-sessions)
+           * and [`Get upload session`](https://developer.box.com/reference/get-files-upload-sessions-id) endpoints.
            * @param {string} uploadSessionId The ID of the upload session.
           Example: "D5E3F7A"
            * @param {GetFileUploadSessionPartsOptionalsInput} optionalsInput
@@ -10384,8 +10386,8 @@
          * This allows to always upload your content to the closest Box data center and can significantly improve upload speed.
          *  Close an upload session and create a file from the uploaded chunks.
          *
-         * The actual endpoint URL is returned by the [`Create upload session`](e://post-files-upload-sessions)
-         * and [`Get upload session`](e://get-files-upload-sessions-id) endpoints.
+         * The actual endpoint URL is returned by the [`Create upload session`](https://developer.box.com/reference/post-files-upload-sessions)
+         * and [`Get upload session`](https://developer.box.com/reference/get-files-upload-sessions-id) endpoints.
          * @param {string} url URL of createFileUploadSessionCommit method
          * @param {CreateFileUploadSessionCommitByUrlRequestBody} requestBody Request body of createFileUploadSessionCommit method
          * @param {CreateFileUploadSessionCommitByUrlHeadersInput} headersInput Headers of createFileUploadSessionCommit method
@@ -10429,8 +10431,8 @@
         /**
            * Close an upload session and create a file from the uploaded chunks.
            *
-           * The actual endpoint URL is returned by the [`Create upload session`](e://post-files-upload-sessions)
-           * and [`Get upload session`](e://get-files-upload-sessions-id) endpoints.
+           * The actual endpoint URL is returned by the [`Create upload session`](https://developer.box.com/reference/post-files-upload-sessions)
+           * and [`Get upload session`](https://developer.box.com/reference/get-files-upload-sessions-id) endpoints.
            * @param {string} uploadSessionId The ID of the upload session.
           Example: "D5E3F7A"
            * @param {CreateFileUploadSessionCommitRequestBody} requestBody Request body of createFileUploadSessionCommit method
@@ -14014,8 +14016,12 @@
 
     class GetFileMetadataOptionals {
         constructor(fields) {
+            this.queryParams = {};
             this.headers = new GetFileMetadataHeaders({});
             this.cancellationToken = void 0;
+            if (fields.queryParams !== undefined) {
+                this.queryParams = fields.queryParams;
+            }
             if (fields.headers !== undefined) {
                 this.headers = fields.headers;
             }
@@ -14026,8 +14032,12 @@
     }
     class GetFileMetadataByIdOptionals {
         constructor(fields) {
+            this.queryParams = {};
             this.headers = new GetFileMetadataByIdHeaders({});
             this.cancellationToken = void 0;
+            if (fields.queryParams !== undefined) {
+                this.queryParams = fields.queryParams;
+            }
             if (fields.headers !== undefined) {
                 this.headers = fields.headers;
             }
@@ -14148,15 +14158,19 @@
         getFileMetadata(fileId_1) {
             return __awaiter$1(this, arguments, void 0, function* (fileId, optionalsInput = {}) {
                 const optionals = new GetFileMetadataOptionals({
+                    queryParams: optionalsInput.queryParams,
                     headers: optionalsInput.headers,
                     cancellationToken: optionalsInput.cancellationToken,
                 });
+                const queryParams = optionals.queryParams;
                 const headers = optionals.headers;
                 const cancellationToken = optionals.cancellationToken;
+                const queryParamsMap = prepareParams({ ['view']: toString(queryParams.view) });
                 const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
                 const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
                     url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/files/', toString(fileId), '/metadata'),
                     method: 'GET',
+                    params: queryParamsMap,
                     headers: headersMap,
                     responseFormat: 'json',
                     auth: this.auth,
@@ -14187,15 +14201,19 @@
         getFileMetadataById(fileId_1, scope_1, templateKey_1) {
             return __awaiter$1(this, arguments, void 0, function* (fileId, scope, templateKey, optionalsInput = {}) {
                 const optionals = new GetFileMetadataByIdOptionals({
+                    queryParams: optionalsInput.queryParams,
                     headers: optionalsInput.headers,
                     cancellationToken: optionalsInput.cancellationToken,
                 });
+                const queryParams = optionals.queryParams;
                 const headers = optionals.headers;
                 const cancellationToken = optionals.cancellationToken;
+                const queryParamsMap = prepareParams({ ['view']: toString(queryParams.view) });
                 const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
                 const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
                     url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/files/', toString(fileId), '/metadata/', toString(scope), '/', toString(templateKey)),
                     method: 'GET',
+                    params: queryParamsMap,
                     headers: headersMap,
                     responseFormat: 'json',
                     auth: this.auth,
@@ -17618,10 +17636,10 @@
            * Passing `sort`, `direction`, `offset`, and `limit`
            * parameters in query allows you to manage the
            * list of returned
-           * [folder items](r://folder--full#param-item-collection).
+           * [folder items](https://developer.box.com/reference/resources/folder--full#param-item-collection).
            *
            * To fetch more items within the folder, use the
-           * [Get items in a folder](e://get-folders-id-items) endpoint.
+           * [Get items in a folder](https://developer.box.com/reference/get-folders-id-items) endpoint.
            * @param {string} folderId The unique identifier that represent a folder.
           
           The ID for any folder can be determined
@@ -18654,10 +18672,10 @@
            * trash can it be retrieved with this API call. If instead one of
            * its parent folders was moved to the trash, only that folder
            * can be inspected using the
-           * [`GET /folders/:id/trash`](e://get_folders_id_trash) API.
+           * [`GET /folders/:id/trash`](https://developer.box.com/reference/get-folders-id-trash) API.
            *
            * To list all items that have been moved to the trash, please
-           * use the [`GET /folders/trash/items`](e://get-folders-trash-items/)
+           * use the [`GET /folders/trash/items`](https://developer.box.com/reference/get-folders-trash-items/)
            * API.
            * @param {string} folderId The unique identifier that represent a folder.
           
@@ -18755,8 +18773,12 @@
 
     class GetFolderMetadataOptionals {
         constructor(fields) {
+            this.queryParams = {};
             this.headers = new GetFolderMetadataHeaders({});
             this.cancellationToken = void 0;
+            if (fields.queryParams !== undefined) {
+                this.queryParams = fields.queryParams;
+            }
             if (fields.headers !== undefined) {
                 this.headers = fields.headers;
             }
@@ -18893,15 +18915,19 @@
         getFolderMetadata(folderId_1) {
             return __awaiter$1(this, arguments, void 0, function* (folderId, optionalsInput = {}) {
                 const optionals = new GetFolderMetadataOptionals({
+                    queryParams: optionalsInput.queryParams,
                     headers: optionalsInput.headers,
                     cancellationToken: optionalsInput.cancellationToken,
                 });
+                const queryParams = optionals.queryParams;
                 const headers = optionals.headers;
                 const cancellationToken = optionals.cancellationToken;
+                const queryParamsMap = prepareParams({ ['view']: toString(queryParams.view) });
                 const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
                 const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
                     url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/folders/', toString(folderId), '/metadata'),
                     method: 'GET',
+                    params: queryParamsMap,
                     headers: headersMap,
                     responseFormat: 'json',
                     auth: this.auth,
@@ -20018,6 +20044,9 @@
         if (val == 'integer') {
             return val;
         }
+        if (val == 'taxonomy') {
+            return val;
+        }
         throw new BoxSdkError({
             message: "Can't deserialize MetadataTemplateFieldsTypeField",
         });
@@ -20703,6 +20732,16 @@
     function serializeCreateMetadataTemplateRequestBodyFieldsOptionsField(val) {
         return { ['key']: val.key };
     }
+    function serializeCreateMetadataTemplateRequestBodyFieldsOptionsRulesField(val) {
+        return {
+            ['multiSelect']: val.multiSelect,
+            ['selectableLevels']: val.selectableLevels == void 0
+                ? val.selectableLevels
+                : val.selectableLevels.map(function (item) {
+                    return item;
+                }),
+        };
+    }
     function serializeCreateMetadataTemplateRequestBodyFieldsField(val) {
         return {
             ['type']: serializeCreateMetadataTemplateRequestBodyFieldsTypeField(val.type),
@@ -20715,6 +20754,11 @@
                 : val.options.map(function (item) {
                     return serializeCreateMetadataTemplateRequestBodyFieldsOptionsField(item);
                 }),
+            ['taxonomyKey']: val.taxonomyKey,
+            ['namespace']: val.namespace,
+            ['optionsRules']: val.optionsRules == void 0
+                ? val.optionsRules
+                : serializeCreateMetadataTemplateRequestBodyFieldsOptionsRulesField(val.optionsRules),
         };
     }
     function serializeCreateMetadataTemplateRequestBody(val) {
@@ -32773,7 +32817,7 @@
          * **Note**:
          * File retention API is now **deprecated**.
          * To get information about files and file versions under retention,
-         * see [files under retention](e://get-retention-policy-assignments-id-files-under-retention) or [file versions under retention](e://get-retention-policy-assignments-id-file-versions-under-retention) endpoints.
+         * see [files under retention](https://developer.box.com/reference/get-retention-policy-assignments-id-files-under-retention) or [file versions under retention](https://developer.box.com/reference/get-retention-policy-assignments-id-file-versions-under-retention) endpoints.
          * @param {GetFileVersionRetentionsQueryParams} queryParams Query parameters of getFileVersionRetentions method
          * @param {GetFileVersionRetentionsHeadersInput} headersInput Headers of getFileVersionRetentions method
          * @param {CancellationToken} cancellationToken Token used for request cancellation.
@@ -32814,7 +32858,7 @@
            * **Note**:
            * File retention API is now **deprecated**.
            * To get information about files and file versions under retention,
-           * see [files under retention](e://get-retention-policy-assignments-id-files-under-retention) or [file versions under retention](e://get-retention-policy-assignments-id-file-versions-under-retention) endpoints.
+           * see [files under retention](https://developer.box.com/reference/get-retention-policy-assignments-id-files-under-retention) or [file versions under retention](https://developer.box.com/reference/get-retention-policy-assignments-id-file-versions-under-retention) endpoints.
            * @param {string} fileVersionRetentionId The ID of the file version retention.
           Example: "3424234"
            * @param {GetFileVersionRetentionByIdOptionalsInput} optionalsInput
@@ -37666,7 +37710,7 @@
            * be created.
            *
            * The URL of this endpoint should not be considered as fixed. Instead, use
-           * the [Create zip download](e://post_zip_downloads) API to request to create a
+           * the [Create zip download](https://developer.box.com/reference/post-zip-downloads) API to request to create a
            * `zip` archive, and then follow the `download_url` field in the response to
            * this endpoint.
            * @param {string} downloadUrl The URL that can be used to download created `zip` archive.
@@ -37705,7 +37749,7 @@
            * download.
            *
            * The URL of this endpoint should not be considered as fixed. Instead, use
-           * the [Create zip download](e://post_zip_downloads) API to request to create a
+           * the [Create zip download](https://developer.box.com/reference/post-zip-downloads) API to request to create a
            * `zip` archive, and then follow the `status_url` field in the response to
            * this endpoint.
            * @param {string} statusUrl The URL that can be used to get the status of the `zip` archive being downloaded.
@@ -37874,6 +37918,394 @@
         };
     }
 
+    function deserializeSignRequestSignerInputEmailValidationValidationTypeField(val) {
+        if (val == 'email') {
+            return val;
+        }
+        if (sdIsString(val)) {
+            return val;
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputEmailValidationValidationTypeField",
+        });
+    }
+    function deserializeSignRequestSignerInputEmailValidation(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "SignRequestSignerInputEmailValidation"',
+            });
+        }
+        if (val.validation_type == void 0) {
+            throw new BoxSdkError({
+                message: 'Expecting "validation_type" of type "SignRequestSignerInputEmailValidation" to be defined',
+            });
+        }
+        const validationType = deserializeSignRequestSignerInputEmailValidationValidationTypeField(val.validation_type);
+        return {
+            validationType: validationType,
+        };
+    }
+
+    function deserializeSignRequestSignerInputCustomValidationValidationTypeField(val) {
+        if (val == 'custom') {
+            return val;
+        }
+        if (sdIsString(val)) {
+            return val;
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputCustomValidationValidationTypeField",
+        });
+    }
+    function deserializeSignRequestSignerInputCustomValidation(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "SignRequestSignerInputCustomValidation"',
+            });
+        }
+        if (val.validation_type == void 0) {
+            throw new BoxSdkError({
+                message: 'Expecting "validation_type" of type "SignRequestSignerInputCustomValidation" to be defined',
+            });
+        }
+        const validationType = deserializeSignRequestSignerInputCustomValidationValidationTypeField(val.validation_type);
+        if (!(val.custom_regex == void 0) && !sdIsString(val.custom_regex)) {
+            throw new BoxSdkError({
+                message: 'Expecting string for "custom_regex" of type "SignRequestSignerInputCustomValidation"',
+            });
+        }
+        const customRegex = val.custom_regex == void 0 ? void 0 : val.custom_regex;
+        if (!(val.custom_error_message == void 0) &&
+            !sdIsString(val.custom_error_message)) {
+            throw new BoxSdkError({
+                message: 'Expecting string for "custom_error_message" of type "SignRequestSignerInputCustomValidation"',
+            });
+        }
+        const customErrorMessage = val.custom_error_message == void 0 ? void 0 : val.custom_error_message;
+        return {
+            validationType: validationType,
+            customRegex: customRegex,
+            customErrorMessage: customErrorMessage,
+        };
+    }
+
+    function deserializeSignRequestSignerInputZipValidationValidationTypeField(val) {
+        if (val == 'zip') {
+            return val;
+        }
+        if (sdIsString(val)) {
+            return val;
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputZipValidationValidationTypeField",
+        });
+    }
+    function deserializeSignRequestSignerInputZipValidation(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "SignRequestSignerInputZipValidation"',
+            });
+        }
+        if (val.validation_type == void 0) {
+            throw new BoxSdkError({
+                message: 'Expecting "validation_type" of type "SignRequestSignerInputZipValidation" to be defined',
+            });
+        }
+        const validationType = deserializeSignRequestSignerInputZipValidationValidationTypeField(val.validation_type);
+        return {
+            validationType: validationType,
+        };
+    }
+
+    function deserializeSignRequestSignerInputZip4ValidationValidationTypeField(val) {
+        if (val == 'zip_4') {
+            return val;
+        }
+        if (sdIsString(val)) {
+            return val;
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputZip4ValidationValidationTypeField",
+        });
+    }
+    function deserializeSignRequestSignerInputZip4Validation(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "SignRequestSignerInputZip4Validation"',
+            });
+        }
+        if (val.validation_type == void 0) {
+            throw new BoxSdkError({
+                message: 'Expecting "validation_type" of type "SignRequestSignerInputZip4Validation" to be defined',
+            });
+        }
+        const validationType = deserializeSignRequestSignerInputZip4ValidationValidationTypeField(val.validation_type);
+        return {
+            validationType: validationType,
+        };
+    }
+
+    function deserializeSignRequestSignerInputSsnValidationValidationTypeField(val) {
+        if (val == 'ssn') {
+            return val;
+        }
+        if (sdIsString(val)) {
+            return val;
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputSsnValidationValidationTypeField",
+        });
+    }
+    function deserializeSignRequestSignerInputSsnValidation(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "SignRequestSignerInputSsnValidation"',
+            });
+        }
+        if (val.validation_type == void 0) {
+            throw new BoxSdkError({
+                message: 'Expecting "validation_type" of type "SignRequestSignerInputSsnValidation" to be defined',
+            });
+        }
+        const validationType = deserializeSignRequestSignerInputSsnValidationValidationTypeField(val.validation_type);
+        return {
+            validationType: validationType,
+        };
+    }
+
+    function deserializeSignRequestSignerInputNumberWithPeriodValidationValidationTypeField(val) {
+        if (val == 'number_with_period') {
+            return val;
+        }
+        if (sdIsString(val)) {
+            return val;
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputNumberWithPeriodValidationValidationTypeField",
+        });
+    }
+    function deserializeSignRequestSignerInputNumberWithPeriodValidation(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "SignRequestSignerInputNumberWithPeriodValidation"',
+            });
+        }
+        const validationType = val.validation_type == void 0
+            ? void 0
+            : deserializeSignRequestSignerInputNumberWithPeriodValidationValidationTypeField(val.validation_type);
+        return {
+            validationType: validationType,
+        };
+    }
+
+    function deserializeSignRequestSignerInputNumberWithCommaValidationValidationTypeField(val) {
+        if (val == 'number_with_comma') {
+            return val;
+        }
+        if (sdIsString(val)) {
+            return val;
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputNumberWithCommaValidationValidationTypeField",
+        });
+    }
+    function deserializeSignRequestSignerInputNumberWithCommaValidation(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "SignRequestSignerInputNumberWithCommaValidation"',
+            });
+        }
+        const validationType = val.validation_type == void 0
+            ? void 0
+            : deserializeSignRequestSignerInputNumberWithCommaValidationValidationTypeField(val.validation_type);
+        return {
+            validationType: validationType,
+        };
+    }
+
+    function deserializeSignRequestSignerInputDateIsoValidationValidationTypeField(val) {
+        if (val == 'date_iso') {
+            return val;
+        }
+        if (sdIsString(val)) {
+            return val;
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputDateIsoValidationValidationTypeField",
+        });
+    }
+    function deserializeSignRequestSignerInputDateIsoValidation(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "SignRequestSignerInputDateIsoValidation"',
+            });
+        }
+        const validationType = val.validation_type == void 0
+            ? void 0
+            : deserializeSignRequestSignerInputDateIsoValidationValidationTypeField(val.validation_type);
+        return {
+            validationType: validationType,
+        };
+    }
+
+    function deserializeSignRequestSignerInputDateUsValidationValidationTypeField(val) {
+        if (val == 'date_us') {
+            return val;
+        }
+        if (sdIsString(val)) {
+            return val;
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputDateUsValidationValidationTypeField",
+        });
+    }
+    function deserializeSignRequestSignerInputDateUsValidation(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "SignRequestSignerInputDateUsValidation"',
+            });
+        }
+        const validationType = val.validation_type == void 0
+            ? void 0
+            : deserializeSignRequestSignerInputDateUsValidationValidationTypeField(val.validation_type);
+        return {
+            validationType: validationType,
+        };
+    }
+
+    function deserializeSignRequestSignerInputDateEuValidationValidationTypeField(val) {
+        if (val == 'date_eu') {
+            return val;
+        }
+        if (sdIsString(val)) {
+            return val;
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputDateEuValidationValidationTypeField",
+        });
+    }
+    function deserializeSignRequestSignerInputDateEuValidation(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "SignRequestSignerInputDateEuValidation"',
+            });
+        }
+        const validationType = val.validation_type == void 0
+            ? void 0
+            : deserializeSignRequestSignerInputDateEuValidationValidationTypeField(val.validation_type);
+        return {
+            validationType: validationType,
+        };
+    }
+
+    function deserializeSignRequestSignerInputDateAsiaValidationValidationTypeField(val) {
+        if (val == 'date_asia') {
+            return val;
+        }
+        if (sdIsString(val)) {
+            return val;
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputDateAsiaValidationValidationTypeField",
+        });
+    }
+    function deserializeSignRequestSignerInputDateAsiaValidation(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "SignRequestSignerInputDateAsiaValidation"',
+            });
+        }
+        const validationType = val.validation_type == void 0
+            ? void 0
+            : deserializeSignRequestSignerInputDateAsiaValidationValidationTypeField(val.validation_type);
+        return {
+            validationType: validationType,
+        };
+    }
+
+    function deserializeSignRequestSignerInputValidation(val) {
+        try {
+            return deserializeSignRequestSignerInputEmailValidation(val);
+        }
+        catch (error) {
+        }
+        finally {
+        }
+        try {
+            return deserializeSignRequestSignerInputCustomValidation(val);
+        }
+        catch (error) {
+        }
+        finally {
+        }
+        try {
+            return deserializeSignRequestSignerInputZipValidation(val);
+        }
+        catch (error) {
+        }
+        finally {
+        }
+        try {
+            return deserializeSignRequestSignerInputZip4Validation(val);
+        }
+        catch (error) {
+        }
+        finally {
+        }
+        try {
+            return deserializeSignRequestSignerInputSsnValidation(val);
+        }
+        catch (error) {
+        }
+        finally {
+        }
+        try {
+            return deserializeSignRequestSignerInputNumberWithPeriodValidation(val);
+        }
+        catch (error) {
+        }
+        finally {
+        }
+        try {
+            return deserializeSignRequestSignerInputNumberWithCommaValidation(val);
+        }
+        catch (error) {
+        }
+        finally {
+        }
+        try {
+            return deserializeSignRequestSignerInputDateIsoValidation(val);
+        }
+        catch (error) {
+        }
+        finally {
+        }
+        try {
+            return deserializeSignRequestSignerInputDateUsValidation(val);
+        }
+        catch (error) {
+        }
+        finally {
+        }
+        try {
+            return deserializeSignRequestSignerInputDateEuValidation(val);
+        }
+        catch (error) {
+        }
+        finally {
+        }
+        try {
+            return deserializeSignRequestSignerInputDateAsiaValidation(val);
+        }
+        catch (error) {
+        }
+        finally {
+        }
+        throw new BoxSdkError({
+            message: "Can't deserialize SignRequestSignerInputValidation",
+        });
+    }
+
     function deserializeSignRequestSignerInputTypeField(val) {
         if (val == 'signature') {
             return val;
@@ -37979,6 +38411,9 @@
             });
         }
         const readOnly = val.read_only == void 0 ? void 0 : val.read_only;
+        const validation = val.validation == void 0
+            ? void 0
+            : deserializeSignRequestSignerInputValidation(val.validation);
         if (!(val.document_tag_id == void 0) && !sdIsString(val.document_tag_id)) {
             throw new BoxSdkError({
                 message: 'Expecting string for "document_tag_id" of type "SignRequestSignerInput"',
@@ -38008,6 +38443,7 @@
             contentType: contentType,
             pageIndex: pageIndex,
             readOnly: readOnly,
+            validation: validation,
             documentTagId: documentTagId,
             textValue: textValue,
             checkboxValue: checkboxValue,
@@ -39809,6 +40245,9 @@
             });
         }
         const readOnly = val.read_only == void 0 ? void 0 : val.read_only;
+        const validation = val.validation == void 0
+            ? void 0
+            : deserializeSignRequestSignerInputValidation(val.validation);
         if (!(val.document_tag_id == void 0) && !sdIsString(val.document_tag_id)) {
             throw new BoxSdkError({
                 message: 'Expecting string for "document_tag_id" of type "TemplateSignerInput"',
@@ -39845,6 +40284,7 @@
             dimensions: dimensions,
             label: label,
             readOnly: readOnly,
+            validation: validation,
             documentTagId: documentTagId,
             textValue: textValue,
             checkboxValue: checkboxValue,
@@ -42943,11 +43383,11 @@
          * Sends an AI request to supported Large Language Models (LLMs) and returns extracted metadata as a set of key-value pairs.
          *
          * To define the extraction structure, provide either a metadata template or a list of fields. To learn more about creating templates, see [Creating metadata templates in the Admin Console](https://support.box.com/hc/en-us/articles/360044194033-Customizing-Metadata-Templates)
-         * or use the [metadata template API](g://metadata/templates/create).
+         * or use the [metadata template API](https://developer.box.com/guides/metadata/templates/create).
          *
-         * This endpoint also supports [Enhanced Extract Agent](g://box-ai/ai-tutorials/extract-metadata-structured/#enhanced-extract-agent).
+         * This endpoint also supports [Enhanced Extract Agent](https://developer.box.com/guides/box-ai/ai-tutorials/extract-metadata-structured#enhanced-extract-agent).
          *
-         * For information about supported file formats and languages, see the [Extract metadata from file (structured)](g://box-ai/ai-tutorials/extract-metadata-structured) API guide.
+         * For information about supported file formats and languages, see the [Extract metadata from file (structured)](https://developer.box.com/guides/box-ai/ai-tutorials/extract-metadata-structured) API guide.
          * @param {AiExtractStructured} requestBody Request body of createAiExtractStructured method
          * @param {CreateAiExtractStructuredOptionalsInput} optionalsInput
          * @returns {Promise<AiExtractStructuredResponse>}
@@ -44184,6 +44624,1248 @@
         }
     }
 
+    function serializeMetadataTaxonomyLevel(val) {
+        return {
+            ['displayName']: val.displayName,
+            ['description']: val.description,
+            ['level']: val.level,
+        };
+    }
+    function deserializeMetadataTaxonomyLevel(val) {
+        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 = 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 = 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 = val.level == void 0 ? void 0 : val.level;
+        return {
+            displayName: displayName,
+            description: description,
+            level: level,
+        };
+    }
+
+    function deserializeMetadataTaxonomy(val) {
+        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 = val.id;
+        if (!(val.key == void 0) && !sdIsString(val.key)) {
+            throw new BoxSdkError({
+                message: 'Expecting string for "key" of type "MetadataTaxonomy"',
+            });
+        }
+        const key = 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 = 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 = val.namespace;
+        if (!(val.levels == void 0) && !sdIsList(val.levels)) {
+            throw new BoxSdkError({
+                message: 'Expecting array for "levels" of type "MetadataTaxonomy"',
+            });
+        }
+        const levels = val.levels == void 0
+            ? void 0
+            : sdIsList(val.levels)
+                ? val.levels.map(function (itm) {
+                    return deserializeMetadataTaxonomyLevel(itm);
+                })
+                : [];
+        return {
+            id: id,
+            key: key,
+            displayName: displayName,
+            namespace: namespace,
+            levels: levels,
+        };
+    }
+
+    function deserializeMetadataTaxonomies(val) {
+        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 = 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 = 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 = 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 = val.entries == void 0
+            ? void 0
+            : sdIsList(val.entries)
+                ? val.entries.map(function (itm) {
+                    return deserializeMetadataTaxonomy(itm);
+                })
+                : [];
+        return {
+            limit: limit,
+            nextMarker: nextMarker,
+            prevMarker: prevMarker,
+            entries: entries,
+        };
+    }
+
+    function deserializeMetadataTaxonomyLevels(val) {
+        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 = val.entries == void 0
+            ? void 0
+            : sdIsList(val.entries)
+                ? val.entries.map(function (itm) {
+                    return deserializeMetadataTaxonomyLevel(itm);
+                })
+                : [];
+        return { entries: entries };
+    }
+
+    function deserializeMetadataTaxonomyAncestor(val) {
+        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 = 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 = 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 = val.level == void 0 ? void 0 : val.level;
+        return {
+            id: id,
+            displayName: displayName,
+            level: level,
+        };
+    }
+
+    function deserializeMetadataTaxonomyNode(val) {
+        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 = 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 = 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 = val.level;
+        if (!(val.parentId == void 0) && !sdIsString(val.parentId)) {
+            throw new BoxSdkError({
+                message: 'Expecting string for "parentId" of type "MetadataTaxonomyNode"',
+            });
+        }
+        const parentId = 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 = val.nodePath == void 0
+            ? void 0
+            : sdIsList(val.nodePath)
+                ? val.nodePath.map(function (itm) {
+                    if (!sdIsString(itm)) {
+                        throw new BoxSdkError({
+                            message: 'Expecting string for "MetadataTaxonomyNode"',
+                        });
+                    }
+                    return itm;
+                })
+                : [];
+        if (!(val.ancestors == void 0) && !sdIsList(val.ancestors)) {
+            throw new BoxSdkError({
+                message: 'Expecting array for "ancestors" of type "MetadataTaxonomyNode"',
+            });
+        }
+        const ancestors = val.ancestors == void 0
+            ? void 0
+            : sdIsList(val.ancestors)
+                ? val.ancestors.map(function (itm) {
+                    return deserializeMetadataTaxonomyAncestor(itm);
+                })
+                : [];
+        return {
+            id: id,
+            displayName: displayName,
+            level: level,
+            parentId: parentId,
+            nodePath: nodePath,
+            ancestors: ancestors,
+        };
+    }
+
+    function deserializeMetadataTaxonomyNodes(val) {
+        if (!sdIsMap(val)) {
+            throw new BoxSdkError({
+                message: 'Expecting a map for "MetadataTaxonomyNodes"',
+            });
+        }
+        if (!(val.limit == void 0) && !sdIsNumber(val.limit)) {
+            throw new BoxSdkError({
+                message: 'Expecting number for "limit" of type "MetadataTaxonomyNodes"',
+            });
+        }
+        const limit = val.limit == void 0 ? void 0 : val.limit;
+        if (!(val.next_marker == void 0) && !sdIsString(val.next_marker)) {
+            throw new BoxSdkError({
+                message: 'Expecting string for "next_marker" of type "MetadataTaxonomyNodes"',
+            });
+        }
+        const nextMarker = val.next_marker == void 0 ? void 0 : val.next_marker;
+        if (!(val.prev_marker == void 0) && !sdIsString(val.prev_marker)) {
+            throw new BoxSdkError({
+                message: 'Expecting string for "prev_marker" of type "MetadataTaxonomyNodes"',
+            });
+        }
+        const prevMarker = val.prev_marker == void 0 ? void 0 : val.prev_marker;
+        if (!(val.entries == void 0) && !sdIsList(val.entries)) {
+            throw new BoxSdkError({
+                message: 'Expecting array for "entries" of type "MetadataTaxonomyNodes"',
+            });
+        }
+        const entries = val.entries == void 0
+            ? void 0
+            : sdIsList(val.entries)
+                ? val.entries.map(function (itm) {
+                    return deserializeMetadataTaxonomyNode(itm);
+                })
+                : [];
+        return {
+            limit: limit,
+            nextMarker: nextMarker,
+            prevMarker: prevMarker,
+            entries: entries,
+        };
+    }
+
+    class CreateMetadataTaxonomyOptionals {
+        constructor(fields) {
+            this.headers = new CreateMetadataTaxonomyHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class GetMetadataTaxonomiesOptionals {
+        constructor(fields) {
+            this.queryParams = {};
+            this.headers = new GetMetadataTaxonomiesHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.queryParams !== undefined) {
+                this.queryParams = fields.queryParams;
+            }
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class GetMetadataTaxonomyByKeyOptionals {
+        constructor(fields) {
+            this.headers = new GetMetadataTaxonomyByKeyHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class UpdateMetadataTaxonomyOptionals {
+        constructor(fields) {
+            this.headers = new UpdateMetadataTaxonomyHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class DeleteMetadataTaxonomyOptionals {
+        constructor(fields) {
+            this.headers = new DeleteMetadataTaxonomyHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class CreateMetadataTaxonomyLevelOptionals {
+        constructor(fields) {
+            this.headers = new CreateMetadataTaxonomyLevelHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class UpdateMetadataTaxonomyLevelByIdOptionals {
+        constructor(fields) {
+            this.headers = new UpdateMetadataTaxonomyLevelByIdHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class AddMetadataTaxonomyLevelOptionals {
+        constructor(fields) {
+            this.headers = new AddMetadataTaxonomyLevelHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class DeleteMetadataTaxonomyLevelOptionals {
+        constructor(fields) {
+            this.headers = new DeleteMetadataTaxonomyLevelHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class GetMetadataTaxonomyNodesOptionals {
+        constructor(fields) {
+            this.queryParams = {};
+            this.headers = new GetMetadataTaxonomyNodesHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.queryParams !== undefined) {
+                this.queryParams = fields.queryParams;
+            }
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class CreateMetadataTaxonomyNodeOptionals {
+        constructor(fields) {
+            this.headers = new CreateMetadataTaxonomyNodeHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class GetMetadataTaxonomyNodeByIdOptionals {
+        constructor(fields) {
+            this.headers = new GetMetadataTaxonomyNodeByIdHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class UpdateMetadataTaxonomyNodeOptionals {
+        constructor(fields) {
+            this.requestBody = {};
+            this.headers = new UpdateMetadataTaxonomyNodeHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.requestBody !== undefined) {
+                this.requestBody = fields.requestBody;
+            }
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class DeleteMetadataTaxonomyNodeOptionals {
+        constructor(fields) {
+            this.headers = new DeleteMetadataTaxonomyNodeHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class GetMetadataTemplateFieldOptionsOptionals {
+        constructor(fields) {
+            this.queryParams = {};
+            this.headers = new GetMetadataTemplateFieldOptionsHeaders({});
+            this.cancellationToken = void 0;
+            if (fields.queryParams !== undefined) {
+                this.queryParams = fields.queryParams;
+            }
+            if (fields.headers !== undefined) {
+                this.headers = fields.headers;
+            }
+            if (fields.cancellationToken !== undefined) {
+                this.cancellationToken = fields.cancellationToken;
+            }
+        }
+    }
+    class CreateMetadataTaxonomyHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class GetMetadataTaxonomiesHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class GetMetadataTaxonomyByKeyHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class UpdateMetadataTaxonomyHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class DeleteMetadataTaxonomyHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class CreateMetadataTaxonomyLevelHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class UpdateMetadataTaxonomyLevelByIdHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class AddMetadataTaxonomyLevelHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class DeleteMetadataTaxonomyLevelHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class GetMetadataTaxonomyNodesHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class CreateMetadataTaxonomyNodeHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class GetMetadataTaxonomyNodeByIdHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class UpdateMetadataTaxonomyNodeHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class DeleteMetadataTaxonomyNodeHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class GetMetadataTemplateFieldOptionsHeaders {
+        constructor(fields) {
+            /**
+             * Extra headers that will be included in the HTTP request. */
+            this.extraHeaders = {};
+            if (fields.extraHeaders !== undefined) {
+                this.extraHeaders = fields.extraHeaders;
+            }
+        }
+    }
+    class MetadataTaxonomiesManager {
+        constructor(fields) {
+            this.networkSession = new 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>}
+         */
+        createMetadataTaxonomy(requestBody_1) {
+            return __awaiter$1(this, arguments, void 0, function* (requestBody, optionalsInput = {}) {
+                const optionals = new CreateMetadataTaxonomyOptionals({
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies'),
+                    method: 'POST',
+                    headers: headersMap,
+                    data: serializeCreateMetadataTaxonomyRequestBody(requestBody),
+                    contentType: 'application/json',
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        getMetadataTaxonomies(namespace_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, optionalsInput = {}) {
+                const optionals = new GetMetadataTaxonomiesOptionals({
+                    queryParams: optionalsInput.queryParams,
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const queryParams = optionals.queryParams;
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const queryParamsMap = prepareParams({
+                    ['marker']: toString(queryParams.marker),
+                    ['limit']: toString(queryParams.limit),
+                });
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace)),
+                    method: 'GET',
+                    params: queryParamsMap,
+                    headers: headersMap,
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        getMetadataTaxonomyByKey(namespace_1, taxonomyKey_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, optionalsInput = {}) {
+                const optionals = new GetMetadataTaxonomyByKeyOptionals({
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey)),
+                    method: 'GET',
+                    headers: headersMap,
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        updateMetadataTaxonomy(namespace_1, taxonomyKey_1, requestBody_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, requestBody, optionalsInput = {}) {
+                const optionals = new UpdateMetadataTaxonomyOptionals({
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey)),
+                    method: 'PATCH',
+                    headers: headersMap,
+                    data: serializeUpdateMetadataTaxonomyRequestBody(requestBody),
+                    contentType: 'application/json',
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        deleteMetadataTaxonomy(namespace_1, taxonomyKey_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, optionalsInput = {}) {
+                const optionals = new DeleteMetadataTaxonomyOptionals({
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey)),
+                    method: 'DELETE',
+                    headers: headersMap,
+                    responseFormat: 'no_content',
+                    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>}
+           */
+        createMetadataTaxonomyLevel(namespace_1, taxonomyKey_1, requestBody_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, requestBody, optionalsInput = {}) {
+                const optionals = new CreateMetadataTaxonomyLevelOptionals({
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey), '/levels'),
+                    method: 'POST',
+                    headers: headersMap,
+                    data: requestBody.map(serializeMetadataTaxonomyLevel),
+                    contentType: 'application/json',
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        updateMetadataTaxonomyLevelById(namespace_1, taxonomyKey_1, levelIndex_1, requestBody_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, levelIndex, requestBody, optionalsInput = {}) {
+                const optionals = new UpdateMetadataTaxonomyLevelByIdOptionals({
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey), '/levels/', toString(levelIndex)),
+                    method: 'PATCH',
+                    headers: headersMap,
+                    data: serializeUpdateMetadataTaxonomyLevelByIdRequestBody(requestBody),
+                    contentType: 'application/json',
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        addMetadataTaxonomyLevel(namespace_1, taxonomyKey_1, requestBody_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, requestBody, optionalsInput = {}) {
+                const optionals = new AddMetadataTaxonomyLevelOptionals({
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey), '/levels:append'),
+                    method: 'POST',
+                    headers: headersMap,
+                    data: serializeAddMetadataTaxonomyLevelRequestBody(requestBody),
+                    contentType: 'application/json',
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        deleteMetadataTaxonomyLevel(namespace_1, taxonomyKey_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, optionalsInput = {}) {
+                const optionals = new DeleteMetadataTaxonomyLevelOptionals({
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey), '/levels:trim'),
+                    method: 'POST',
+                    headers: headersMap,
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        getMetadataTaxonomyNodes(namespace_1, taxonomyKey_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, optionalsInput = {}) {
+                const optionals = new GetMetadataTaxonomyNodesOptionals({
+                    queryParams: optionalsInput.queryParams,
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const queryParams = optionals.queryParams;
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const queryParamsMap = 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),
+                    ['include-total-result-count']: toString(queryParams.includeTotalResultCount),
+                    ['marker']: toString(queryParams.marker),
+                    ['limit']: toString(queryParams.limit),
+                });
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey), '/nodes'),
+                    method: 'GET',
+                    params: queryParamsMap,
+                    headers: headersMap,
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        createMetadataTaxonomyNode(namespace_1, taxonomyKey_1, requestBody_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, requestBody, optionalsInput = {}) {
+                const optionals = new CreateMetadataTaxonomyNodeOptionals({
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey), '/nodes'),
+                    method: 'POST',
+                    headers: headersMap,
+                    data: serializeCreateMetadataTaxonomyNodeRequestBody(requestBody),
+                    contentType: 'application/json',
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        getMetadataTaxonomyNodeById(namespace_1, taxonomyKey_1, nodeId_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, nodeId, optionalsInput = {}) {
+                const optionals = new GetMetadataTaxonomyNodeByIdOptionals({
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey), '/nodes/', toString(nodeId)),
+                    method: 'GET',
+                    headers: headersMap,
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        updateMetadataTaxonomyNode(namespace_1, taxonomyKey_1, nodeId_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, nodeId, optionalsInput = {}) {
+                const optionals = new UpdateMetadataTaxonomyNodeOptionals({
+                    requestBody: optionalsInput.requestBody,
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const requestBody = optionals.requestBody;
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey), '/nodes/', toString(nodeId)),
+                    method: 'PATCH',
+                    headers: headersMap,
+                    data: serializeUpdateMetadataTaxonomyNodeRequestBody(requestBody),
+                    contentType: 'application/json',
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, 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>}
+           */
+        deleteMetadataTaxonomyNode(namespace_1, taxonomyKey_1, nodeId_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, taxonomyKey, nodeId, optionalsInput = {}) {
+                const optionals = new DeleteMetadataTaxonomyNodeOptionals({
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', toString(namespace), '/', toString(taxonomyKey), '/nodes/', toString(nodeId)),
+                    method: 'DELETE',
+                    headers: headersMap,
+                    responseFormat: 'no_content',
+                    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>}
+           */
+        getMetadataTemplateFieldOptions(namespace_1, templateKey_1, fieldKey_1) {
+            return __awaiter$1(this, arguments, void 0, function* (namespace, templateKey, fieldKey, optionalsInput = {}) {
+                const optionals = new GetMetadataTemplateFieldOptionsOptionals({
+                    queryParams: optionalsInput.queryParams,
+                    headers: optionalsInput.headers,
+                    cancellationToken: optionalsInput.cancellationToken,
+                });
+                const queryParams = optionals.queryParams;
+                const headers = optionals.headers;
+                const cancellationToken = optionals.cancellationToken;
+                const queryParamsMap = 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),
+                    ['include-total-result-count']: toString(queryParams.includeTotalResultCount),
+                    ['only-selectable-options']: toString(queryParams.onlySelectableOptions),
+                    ['marker']: toString(queryParams.marker),
+                    ['limit']: toString(queryParams.limit),
+                });
+                const headersMap = prepareParams(Object.assign({}, headers.extraHeaders));
+                const response = yield this.networkSession.networkClient.fetch(new FetchOptions({
+                    url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_templates/', toString(namespace), '/', toString(templateKey), '/fields/', toString(fieldKey), '/options'),
+                    method: 'GET',
+                    params: queryParamsMap,
+                    headers: headersMap,
+                    responseFormat: 'json',
+                    auth: this.auth,
+                    networkSession: this.networkSession,
+                    cancellationToken: cancellationToken,
+                }));
+                return Object.assign(Object.assign({}, deserializeMetadataTaxonomyNodes(response.data)), { rawData: response.data });
+            });
+        }
+    }
+    function serializeCreateMetadataTaxonomyRequestBody(val) {
+        return {
+            ['key']: val.key,
+            ['displayName']: val.displayName,
+            ['namespace']: val.namespace,
+        };
+    }
+    function serializeUpdateMetadataTaxonomyRequestBody(val) {
+        return { ['displayName']: val.displayName };
+    }
+    function serializeUpdateMetadataTaxonomyLevelByIdRequestBody(val) {
+        return { ['displayName']: val.displayName, ['description']: val.description };
+    }
+    function serializeAddMetadataTaxonomyLevelRequestBody(val) {
+        return { ['displayName']: val.displayName, ['description']: val.description };
+    }
+    function serializeCreateMetadataTaxonomyNodeRequestBody(val) {
+        return {
+            ['displayName']: val.displayName,
+            ['level']: val.level,
+            ['parentId']: val.parentId,
+        };
+    }
+    function serializeUpdateMetadataTaxonomyNodeRequestBody(val) {
+        return { ['displayName']: val.displayName };
+    }
+
     function serializeFileReferenceV2025R0TypeField(val) {
         return val;
     }
@@ -49897,7 +51579,7 @@
         /**
          * Retrieves archives for an enterprise.
          *
-         * To learn more about the archive APIs, see the [Archive API Guide](g://archives).
+         * To learn more about the archive APIs, see the [Archive API Guide](https://developer.box.com/guides/archives).
          * @param {GetArchivesV2025R0QueryParams} queryParams Query parameters of getArchivesV2025R0 method
          * @param {GetArchivesV2025R0HeadersInput} headersInput Headers of getArchivesV2025R0 method
          * @param {CancellationToken} cancellationToken Token used for request cancellation.
@@ -49930,7 +51612,7 @@
         /**
          * Creates an archive.
          *
-         * To learn more about the archive APIs, see the [Archive API Guide](g://archives).
+         * To learn more about the archive APIs, see the [Archive API Guide](https://developer.box.com/guides/archives).
          * @param {CreateArchiveV2025R0RequestBody} requestBody Request body of createArchiveV2025R0 method
          * @param {CreateArchiveV2025R0OptionalsInput} optionalsInput
          * @returns {Promise<ArchiveV2025R0>}
@@ -49961,7 +51643,7 @@
         /**
            * Permanently deletes an archive.
            *
-           * To learn more about the archive APIs, see the [Archive API Guide](g://archives).
+           * To learn more about the archive APIs, see the [Archive API Guide](https://developer.box.com/guides/archives).
            * @param {string} archiveId The ID of the archive.
           Example: "982312"
            * @param {DeleteArchiveByIdV2025R0OptionalsInput} optionalsInput
@@ -49991,7 +51673,7 @@
         /**
            * Updates an archive.
            *
-           * To learn more about the archive APIs, see the [Archive API Guide](g://archives).
+           * To learn more about the archive APIs, see the [Archive API Guide](https://developer.box.com/guides/archives).
            * @param {string} archiveId The ID of the archive.
           Example: "982312"
            * @param {UpdateArchiveByIdV2025R0OptionalsInput} optionalsInput
@@ -50494,6 +52176,10 @@
                 auth: this.auth,
                 networkSession: this.networkSession,
             });
+            this.metadataTaxonomies = new MetadataTaxonomiesManager({
+                auth: this.auth,
+                networkSession: this.networkSession,
+            });
             this.docgenTemplate = new DocgenTemplateManager({
                 auth: this.auth,
                 networkSession: this.networkSession,