box-node-sdk 10.2.0 → 10.4.0

package/lib-esm/managers/metadataTaxonomies.js

@@ -0,0 +1,1112 @@
+import { deserializeMetadataTaxonomy } from '../schemas/metadataTaxonomy.js';
+import { deserializeMetadataTaxonomies } from '../schemas/metadataTaxonomies.js';
+import { deserializeMetadataTaxonomyLevels } from '../schemas/metadataTaxonomyLevels.js';
+import { serializeMetadataTaxonomyLevel } from '../schemas/metadataTaxonomyLevel.js';
+import { deserializeMetadataTaxonomyLevel } from '../schemas/metadataTaxonomyLevel.js';
+import { deserializeMetadataTaxonomyNodes } from '../schemas/metadataTaxonomyNodes.js';
+import { deserializeMetadataTaxonomyNode } from '../schemas/metadataTaxonomyNode.js';
+import { BoxSdkError } from '../box/errors.js';
+import { NetworkSession } from '../networking/network.js';
+import { FetchOptions } from '../networking/fetchOptions.js';
+import { prepareParams } from '../internal/utils.js';
+import { toString } from '../internal/utils.js';
+import { sdIsNumber } from '../serialization/json.js';
+import { sdIsString } from '../serialization/json.js';
+import { sdIsMap } from '../serialization/json.js';
+export class CreateMetadataTaxonomyOptionals {
+    headers = new CreateMetadataTaxonomyHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class GetMetadataTaxonomiesOptionals {
+    queryParams = {};
+    headers = new GetMetadataTaxonomiesHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.queryParams !== undefined) {
+            this.queryParams = fields.queryParams;
+        }
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class GetMetadataTaxonomyByKeyOptionals {
+    headers = new GetMetadataTaxonomyByKeyHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class UpdateMetadataTaxonomyOptionals {
+    headers = new UpdateMetadataTaxonomyHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class DeleteMetadataTaxonomyOptionals {
+    headers = new DeleteMetadataTaxonomyHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class CreateMetadataTaxonomyLevelOptionals {
+    headers = new CreateMetadataTaxonomyLevelHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class UpdateMetadataTaxonomyLevelByIdOptionals {
+    headers = new UpdateMetadataTaxonomyLevelByIdHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class AddMetadataTaxonomyLevelOptionals {
+    headers = new AddMetadataTaxonomyLevelHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class DeleteMetadataTaxonomyLevelOptionals {
+    headers = new DeleteMetadataTaxonomyLevelHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class GetMetadataTaxonomyNodesOptionals {
+    queryParams = {};
+    headers = new GetMetadataTaxonomyNodesHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.queryParams !== undefined) {
+            this.queryParams = fields.queryParams;
+        }
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class CreateMetadataTaxonomyNodeOptionals {
+    headers = new CreateMetadataTaxonomyNodeHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class GetMetadataTaxonomyNodeByIdOptionals {
+    headers = new GetMetadataTaxonomyNodeByIdHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class UpdateMetadataTaxonomyNodeOptionals {
+    requestBody = {};
+    headers = new UpdateMetadataTaxonomyNodeHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.requestBody !== undefined) {
+            this.requestBody = fields.requestBody;
+        }
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class DeleteMetadataTaxonomyNodeOptionals {
+    headers = new DeleteMetadataTaxonomyNodeHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class GetMetadataTemplateFieldOptionsOptionals {
+    queryParams = {};
+    headers = new GetMetadataTemplateFieldOptionsHeaders({});
+    cancellationToken = void 0;
+    constructor(fields) {
+        if (fields.queryParams !== undefined) {
+            this.queryParams = fields.queryParams;
+        }
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+export class CreateMetadataTaxonomyHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class GetMetadataTaxonomiesHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class GetMetadataTaxonomyByKeyHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class UpdateMetadataTaxonomyHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class DeleteMetadataTaxonomyHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class CreateMetadataTaxonomyLevelHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class UpdateMetadataTaxonomyLevelByIdHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class AddMetadataTaxonomyLevelHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class DeleteMetadataTaxonomyLevelHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class GetMetadataTaxonomyNodesHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class CreateMetadataTaxonomyNodeHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class GetMetadataTaxonomyNodeByIdHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class UpdateMetadataTaxonomyNodeHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class DeleteMetadataTaxonomyNodeHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class GetMetadataTemplateFieldOptionsHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    extraHeaders = {};
+    constructor(fields) {
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+export class MetadataTaxonomiesManager {
+    auth;
+    networkSession = new NetworkSession({});
+    constructor(fields) {
+        if (fields.auth !== undefined) {
+            this.auth = fields.auth;
+        }
+        if (fields.networkSession !== undefined) {
+            this.networkSession = fields.networkSession;
+        }
+    }
+    /**
+     * Creates a new metadata taxonomy that can be used in
+     * metadata templates.
+     * @param {CreateMetadataTaxonomyRequestBody} requestBody Request body of createMetadataTaxonomy method
+     * @param {CreateMetadataTaxonomyOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataTaxonomy>}
+     */
+    async createMetadataTaxonomy(requestBody, optionalsInput = {}) {
+        const optionals = new CreateMetadataTaxonomyOptionals({
+            headers: optionalsInput.headers,
+            cancellationToken: optionalsInput.cancellationToken,
+        });
+        const headers = optionals.headers;
+        const cancellationToken = optionals.cancellationToken;
+        const headersMap = prepareParams({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomy(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Used to retrieve all metadata taxonomies in a namespace.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {GetMetadataTaxonomiesOptionalsInput} optionalsInput
+       * @returns {Promise<MetadataTaxonomies>}
+       */
+    async getMetadataTaxonomies(namespace, 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({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomies(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Used to retrieve a metadata taxonomy by taxonomy key.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {string} taxonomyKey The key of the metadata taxonomy.
+      Example: "geography"
+       * @param {GetMetadataTaxonomyByKeyOptionalsInput} optionalsInput
+       * @returns {Promise<MetadataTaxonomy>}
+       */
+    async getMetadataTaxonomyByKey(namespace, taxonomyKey, optionalsInput = {}) {
+        const optionals = new GetMetadataTaxonomyByKeyOptionals({
+            headers: optionalsInput.headers,
+            cancellationToken: optionalsInput.cancellationToken,
+        });
+        const headers = optionals.headers;
+        const cancellationToken = optionals.cancellationToken;
+        const headersMap = prepareParams({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomy(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Updates an existing metadata taxonomy.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {string} taxonomyKey The key of the metadata taxonomy.
+      Example: "geography"
+       * @param {UpdateMetadataTaxonomyRequestBody} requestBody Request body of updateMetadataTaxonomy method
+       * @param {UpdateMetadataTaxonomyOptionalsInput} optionalsInput
+       * @returns {Promise<MetadataTaxonomy>}
+       */
+    async updateMetadataTaxonomy(namespace, taxonomyKey, requestBody, optionalsInput = {}) {
+        const optionals = new UpdateMetadataTaxonomyOptionals({
+            headers: optionalsInput.headers,
+            cancellationToken: optionalsInput.cancellationToken,
+        });
+        const headers = optionals.headers;
+        const cancellationToken = optionals.cancellationToken;
+        const headersMap = prepareParams({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomy(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Delete a metadata taxonomy.
+       * This deletion is permanent and cannot be reverted.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {string} taxonomyKey The key of the metadata taxonomy.
+      Example: "geography"
+       * @param {DeleteMetadataTaxonomyOptionalsInput} optionalsInput
+       * @returns {Promise<undefined>}
+       */
+    async deleteMetadataTaxonomy(namespace, taxonomyKey, optionalsInput = {}) {
+        const optionals = new DeleteMetadataTaxonomyOptionals({
+            headers: optionalsInput.headers,
+            cancellationToken: optionalsInput.cancellationToken,
+        });
+        const headers = optionals.headers;
+        const cancellationToken = optionals.cancellationToken;
+        const headersMap = prepareParams({ ...{}, ...headers.extraHeaders });
+        const response = await 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>}
+       */
+    async createMetadataTaxonomyLevel(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({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomyLevels(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Updates an existing metadata taxonomy level.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {string} taxonomyKey The key of the metadata taxonomy.
+      Example: "geography"
+       * @param {number} levelIndex The index of the metadata taxonomy level.
+      Example: 1
+       * @param {UpdateMetadataTaxonomyLevelByIdRequestBody} requestBody Request body of updateMetadataTaxonomyLevelById method
+       * @param {UpdateMetadataTaxonomyLevelByIdOptionalsInput} optionalsInput
+       * @returns {Promise<MetadataTaxonomyLevel>}
+       */
+    async updateMetadataTaxonomyLevelById(namespace, 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({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomyLevel(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Creates a new metadata taxonomy level and appends it to the existing levels.
+       * If there are no levels defined yet, this will create the first level.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {string} taxonomyKey The key of the metadata taxonomy.
+      Example: "geography"
+       * @param {AddMetadataTaxonomyLevelRequestBody} requestBody Request body of addMetadataTaxonomyLevel method
+       * @param {AddMetadataTaxonomyLevelOptionalsInput} optionalsInput
+       * @returns {Promise<MetadataTaxonomyLevels>}
+       */
+    async addMetadataTaxonomyLevel(namespace, taxonomyKey, requestBody, optionalsInput = {}) {
+        const optionals = new AddMetadataTaxonomyLevelOptionals({
+            headers: optionalsInput.headers,
+            cancellationToken: optionalsInput.cancellationToken,
+        });
+        const headers = optionals.headers;
+        const cancellationToken = optionals.cancellationToken;
+        const headersMap = prepareParams({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomyLevels(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Deletes the last level of the metadata taxonomy.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {string} taxonomyKey The key of the metadata taxonomy.
+      Example: "geography"
+       * @param {DeleteMetadataTaxonomyLevelOptionalsInput} optionalsInput
+       * @returns {Promise<MetadataTaxonomyLevels>}
+       */
+    async deleteMetadataTaxonomyLevel(namespace, taxonomyKey, optionalsInput = {}) {
+        const optionals = new DeleteMetadataTaxonomyLevelOptionals({
+            headers: optionalsInput.headers,
+            cancellationToken: optionalsInput.cancellationToken,
+        });
+        const headers = optionals.headers;
+        const cancellationToken = optionals.cancellationToken;
+        const headersMap = prepareParams({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomyLevels(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Used to retrieve metadata taxonomy nodes based on the parameters specified.
+       * Results are sorted in lexicographic order unless a `query` parameter is passed.
+       * With a `query` parameter specified, results are sorted in order of relevance.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {string} taxonomyKey The key of the metadata taxonomy.
+      Example: "geography"
+       * @param {GetMetadataTaxonomyNodesOptionalsInput} optionalsInput
+       * @returns {Promise<MetadataTaxonomyNodes>}
+       */
+    async getMetadataTaxonomyNodes(namespace, 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({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomyNodes(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Creates a new metadata taxonomy node.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {string} taxonomyKey The key of the metadata taxonomy.
+      Example: "geography"
+       * @param {CreateMetadataTaxonomyNodeRequestBody} requestBody Request body of createMetadataTaxonomyNode method
+       * @param {CreateMetadataTaxonomyNodeOptionalsInput} optionalsInput
+       * @returns {Promise<MetadataTaxonomyNode>}
+       */
+    async createMetadataTaxonomyNode(namespace, taxonomyKey, requestBody, optionalsInput = {}) {
+        const optionals = new CreateMetadataTaxonomyNodeOptionals({
+            headers: optionalsInput.headers,
+            cancellationToken: optionalsInput.cancellationToken,
+        });
+        const headers = optionals.headers;
+        const cancellationToken = optionals.cancellationToken;
+        const headersMap = prepareParams({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomyNode(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Retrieves a metadata taxonomy node by its identifier.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {string} taxonomyKey The key of the metadata taxonomy.
+      Example: "geography"
+       * @param {string} nodeId The identifier of the metadata taxonomy node.
+      Example: "14d3d433-c77f-49c5-b146-9dea370f6e32"
+       * @param {GetMetadataTaxonomyNodeByIdOptionalsInput} optionalsInput
+       * @returns {Promise<MetadataTaxonomyNode>}
+       */
+    async getMetadataTaxonomyNodeById(namespace, taxonomyKey, nodeId, optionalsInput = {}) {
+        const optionals = new GetMetadataTaxonomyNodeByIdOptionals({
+            headers: optionalsInput.headers,
+            cancellationToken: optionalsInput.cancellationToken,
+        });
+        const headers = optionals.headers;
+        const cancellationToken = optionals.cancellationToken;
+        const headersMap = prepareParams({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomyNode(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Updates an existing metadata taxonomy node.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {string} taxonomyKey The key of the metadata taxonomy.
+      Example: "geography"
+       * @param {string} nodeId The identifier of the metadata taxonomy node.
+      Example: "14d3d433-c77f-49c5-b146-9dea370f6e32"
+       * @param {UpdateMetadataTaxonomyNodeOptionalsInput} optionalsInput
+       * @returns {Promise<MetadataTaxonomyNode>}
+       */
+    async updateMetadataTaxonomyNode(namespace, 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({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomyNode(response.data),
+            rawData: response.data,
+        };
+    }
+    /**
+       * Delete a metadata taxonomy node.
+       * This deletion is permanent and cannot be reverted.
+       * Only metadata taxonomy nodes without any children can be deleted.
+       * @param {string} namespace The namespace of the metadata taxonomy.
+      Example: "enterprise_123456"
+       * @param {string} taxonomyKey The key of the metadata taxonomy.
+      Example: "geography"
+       * @param {string} nodeId The identifier of the metadata taxonomy node.
+      Example: "14d3d433-c77f-49c5-b146-9dea370f6e32"
+       * @param {DeleteMetadataTaxonomyNodeOptionalsInput} optionalsInput
+       * @returns {Promise<undefined>}
+       */
+    async deleteMetadataTaxonomyNode(namespace, taxonomyKey, nodeId, optionalsInput = {}) {
+        const optionals = new DeleteMetadataTaxonomyNodeOptionals({
+            headers: optionalsInput.headers,
+            cancellationToken: optionalsInput.cancellationToken,
+        });
+        const headers = optionals.headers;
+        const cancellationToken = optionals.cancellationToken;
+        const headersMap = prepareParams({ ...{}, ...headers.extraHeaders });
+        const response = await 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>}
+       */
+    async getMetadataTemplateFieldOptions(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({ ...{}, ...headers.extraHeaders });
+        const response = await 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 {
+            ...deserializeMetadataTaxonomyNodes(response.data),
+            rawData: response.data,
+        };
+    }
+}
+export function serializeCreateMetadataTaxonomyRequestBody(val) {
+    return {
+        ['key']: val.key,
+        ['displayName']: val.displayName,
+        ['namespace']: val.namespace,
+    };
+}
+export function deserializeCreateMetadataTaxonomyRequestBody(val) {
+    if (!sdIsMap(val)) {
+        throw new BoxSdkError({
+            message: 'Expecting a map for "CreateMetadataTaxonomyRequestBody"',
+        });
+    }
+    if (!(val.key == void 0) && !sdIsString(val.key)) {
+        throw new BoxSdkError({
+            message: 'Expecting string for "key" of type "CreateMetadataTaxonomyRequestBody"',
+        });
+    }
+    const key = val.key == void 0 ? void 0 : val.key;
+    if (val.displayName == void 0) {
+        throw new BoxSdkError({
+            message: 'Expecting "displayName" of type "CreateMetadataTaxonomyRequestBody" to be defined',
+        });
+    }
+    if (!sdIsString(val.displayName)) {
+        throw new BoxSdkError({
+            message: 'Expecting string for "displayName" of type "CreateMetadataTaxonomyRequestBody"',
+        });
+    }
+    const displayName = val.displayName;
+    if (val.namespace == void 0) {
+        throw new BoxSdkError({
+            message: 'Expecting "namespace" of type "CreateMetadataTaxonomyRequestBody" to be defined',
+        });
+    }
+    if (!sdIsString(val.namespace)) {
+        throw new BoxSdkError({
+            message: 'Expecting string for "namespace" of type "CreateMetadataTaxonomyRequestBody"',
+        });
+    }
+    const namespace = val.namespace;
+    return {
+        key: key,
+        displayName: displayName,
+        namespace: namespace,
+    };
+}
+export function serializeUpdateMetadataTaxonomyRequestBody(val) {
+    return { ['displayName']: val.displayName };
+}
+export function deserializeUpdateMetadataTaxonomyRequestBody(val) {
+    if (!sdIsMap(val)) {
+        throw new BoxSdkError({
+            message: 'Expecting a map for "UpdateMetadataTaxonomyRequestBody"',
+        });
+    }
+    if (val.displayName == void 0) {
+        throw new BoxSdkError({
+            message: 'Expecting "displayName" of type "UpdateMetadataTaxonomyRequestBody" to be defined',
+        });
+    }
+    if (!sdIsString(val.displayName)) {
+        throw new BoxSdkError({
+            message: 'Expecting string for "displayName" of type "UpdateMetadataTaxonomyRequestBody"',
+        });
+    }
+    const displayName = val.displayName;
+    return {
+        displayName: displayName,
+    };
+}
+export function serializeUpdateMetadataTaxonomyLevelByIdRequestBody(val) {
+    return { ['displayName']: val.displayName, ['description']: val.description };
+}
+export function deserializeUpdateMetadataTaxonomyLevelByIdRequestBody(val) {
+    if (!sdIsMap(val)) {
+        throw new BoxSdkError({
+            message: 'Expecting a map for "UpdateMetadataTaxonomyLevelByIdRequestBody"',
+        });
+    }
+    if (val.displayName == void 0) {
+        throw new BoxSdkError({
+            message: 'Expecting "displayName" of type "UpdateMetadataTaxonomyLevelByIdRequestBody" to be defined',
+        });
+    }
+    if (!sdIsString(val.displayName)) {
+        throw new BoxSdkError({
+            message: 'Expecting string for "displayName" of type "UpdateMetadataTaxonomyLevelByIdRequestBody"',
+        });
+    }
+    const displayName = val.displayName;
+    if (!(val.description == void 0) && !sdIsString(val.description)) {
+        throw new BoxSdkError({
+            message: 'Expecting string for "description" of type "UpdateMetadataTaxonomyLevelByIdRequestBody"',
+        });
+    }
+    const description = val.description == void 0 ? void 0 : val.description;
+    return {
+        displayName: displayName,
+        description: description,
+    };
+}
+export function serializeAddMetadataTaxonomyLevelRequestBody(val) {
+    return { ['displayName']: val.displayName, ['description']: val.description };
+}
+export function deserializeAddMetadataTaxonomyLevelRequestBody(val) {
+    if (!sdIsMap(val)) {
+        throw new BoxSdkError({
+            message: 'Expecting a map for "AddMetadataTaxonomyLevelRequestBody"',
+        });
+    }
+    if (val.displayName == void 0) {
+        throw new BoxSdkError({
+            message: 'Expecting "displayName" of type "AddMetadataTaxonomyLevelRequestBody" to be defined',
+        });
+    }
+    if (!sdIsString(val.displayName)) {
+        throw new BoxSdkError({
+            message: 'Expecting string for "displayName" of type "AddMetadataTaxonomyLevelRequestBody"',
+        });
+    }
+    const displayName = val.displayName;
+    if (!(val.description == void 0) && !sdIsString(val.description)) {
+        throw new BoxSdkError({
+            message: 'Expecting string for "description" of type "AddMetadataTaxonomyLevelRequestBody"',
+        });
+    }
+    const description = val.description == void 0 ? void 0 : val.description;
+    return {
+        displayName: displayName,
+        description: description,
+    };
+}
+export function serializeCreateMetadataTaxonomyNodeRequestBody(val) {
+    return {
+        ['displayName']: val.displayName,
+        ['level']: val.level,
+        ['parentId']: val.parentId,
+    };
+}
+export function deserializeCreateMetadataTaxonomyNodeRequestBody(val) {
+    if (!sdIsMap(val)) {
+        throw new BoxSdkError({
+            message: 'Expecting a map for "CreateMetadataTaxonomyNodeRequestBody"',
+        });
+    }
+    if (val.displayName == void 0) {
+        throw new BoxSdkError({
+            message: 'Expecting "displayName" of type "CreateMetadataTaxonomyNodeRequestBody" to be defined',
+        });
+    }
+    if (!sdIsString(val.displayName)) {
+        throw new BoxSdkError({
+            message: 'Expecting string for "displayName" of type "CreateMetadataTaxonomyNodeRequestBody"',
+        });
+    }
+    const displayName = val.displayName;
+    if (val.level == void 0) {
+        throw new BoxSdkError({
+            message: 'Expecting "level" of type "CreateMetadataTaxonomyNodeRequestBody" to be defined',
+        });
+    }
+    if (!sdIsNumber(val.level)) {
+        throw new BoxSdkError({
+            message: 'Expecting number for "level" of type "CreateMetadataTaxonomyNodeRequestBody"',
+        });
+    }
+    const level = val.level;
+    if (!(val.parentId == void 0) && !sdIsString(val.parentId)) {
+        throw new BoxSdkError({
+            message: 'Expecting string for "parentId" of type "CreateMetadataTaxonomyNodeRequestBody"',
+        });
+    }
+    const parentId = val.parentId == void 0 ? void 0 : val.parentId;
+    return {
+        displayName: displayName,
+        level: level,
+        parentId: parentId,
+    };
+}
+export function serializeUpdateMetadataTaxonomyNodeRequestBody(val) {
+    return { ['displayName']: val.displayName };
+}
+export function deserializeUpdateMetadataTaxonomyNodeRequestBody(val) {
+    if (!sdIsMap(val)) {
+        throw new BoxSdkError({
+            message: 'Expecting a map for "UpdateMetadataTaxonomyNodeRequestBody"',
+        });
+    }
+    if (!(val.displayName == void 0) && !sdIsString(val.displayName)) {
+        throw new BoxSdkError({
+            message: 'Expecting string for "displayName" of type "UpdateMetadataTaxonomyNodeRequestBody"',
+        });
+    }
+    const displayName = val.displayName == void 0 ? void 0 : val.displayName;
+    return {
+        displayName: displayName,
+    };
+}
+//# sourceMappingURL=metadataTaxonomies.js.map