"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MetadataTaxonomiesManager = exports.GetMetadataTemplateFieldOptionsHeaders = exports.DeleteMetadataTaxonomyNodeHeaders = exports.UpdateMetadataTaxonomyNodeHeaders = exports.GetMetadataTaxonomyNodeByIdHeaders = exports.CreateMetadataTaxonomyNodeHeaders = exports.GetMetadataTaxonomyNodesHeaders = exports.DeleteMetadataTaxonomyLevelHeaders = exports.AddMetadataTaxonomyLevelHeaders = exports.UpdateMetadataTaxonomyLevelByIdHeaders = exports.CreateMetadataTaxonomyLevelHeaders = exports.DeleteMetadataTaxonomyHeaders = exports.UpdateMetadataTaxonomyHeaders = exports.GetMetadataTaxonomyByKeyHeaders = exports.GetMetadataTaxonomiesHeaders = exports.CreateMetadataTaxonomyHeaders = exports.GetMetadataTemplateFieldOptionsOptionals = exports.DeleteMetadataTaxonomyNodeOptionals = exports.UpdateMetadataTaxonomyNodeOptionals = exports.GetMetadataTaxonomyNodeByIdOptionals = exports.CreateMetadataTaxonomyNodeOptionals = exports.GetMetadataTaxonomyNodesOptionals = exports.DeleteMetadataTaxonomyLevelOptionals = exports.AddMetadataTaxonomyLevelOptionals = exports.UpdateMetadataTaxonomyLevelByIdOptionals = exports.CreateMetadataTaxonomyLevelOptionals = exports.DeleteMetadataTaxonomyOptionals = exports.UpdateMetadataTaxonomyOptionals = exports.GetMetadataTaxonomyByKeyOptionals = exports.GetMetadataTaxonomiesOptionals = exports.CreateMetadataTaxonomyOptionals = void 0;
exports.serializeCreateMetadataTaxonomyRequestBody = serializeCreateMetadataTaxonomyRequestBody;
exports.deserializeCreateMetadataTaxonomyRequestBody = deserializeCreateMetadataTaxonomyRequestBody;
exports.serializeUpdateMetadataTaxonomyRequestBody = serializeUpdateMetadataTaxonomyRequestBody;
exports.deserializeUpdateMetadataTaxonomyRequestBody = deserializeUpdateMetadataTaxonomyRequestBody;
exports.serializeUpdateMetadataTaxonomyLevelByIdRequestBody = serializeUpdateMetadataTaxonomyLevelByIdRequestBody;
exports.deserializeUpdateMetadataTaxonomyLevelByIdRequestBody = deserializeUpdateMetadataTaxonomyLevelByIdRequestBody;
exports.serializeAddMetadataTaxonomyLevelRequestBody = serializeAddMetadataTaxonomyLevelRequestBody;
exports.deserializeAddMetadataTaxonomyLevelRequestBody = deserializeAddMetadataTaxonomyLevelRequestBody;
exports.serializeCreateMetadataTaxonomyNodeRequestBody = serializeCreateMetadataTaxonomyNodeRequestBody;
exports.deserializeCreateMetadataTaxonomyNodeRequestBody = deserializeCreateMetadataTaxonomyNodeRequestBody;
exports.serializeUpdateMetadataTaxonomyNodeRequestBody = serializeUpdateMetadataTaxonomyNodeRequestBody;
exports.deserializeUpdateMetadataTaxonomyNodeRequestBody = deserializeUpdateMetadataTaxonomyNodeRequestBody;
const metadataTaxonomy_1 = require("../schemas/metadataTaxonomy.js");
const metadataTaxonomies_1 = require("../schemas/metadataTaxonomies.js");
const metadataTaxonomyLevels_1 = require("../schemas/metadataTaxonomyLevels.js");
const metadataTaxonomyLevel_1 = require("../schemas/metadataTaxonomyLevel.js");
const metadataTaxonomyLevel_2 = require("../schemas/metadataTaxonomyLevel.js");
const metadataTaxonomyNodes_1 = require("../schemas/metadataTaxonomyNodes.js");
const metadataTaxonomyNode_1 = require("../schemas/metadataTaxonomyNode.js");
const errors_1 = require("../box/errors.js");
const network_1 = require("../networking/network.js");
const fetchOptions_1 = require("../networking/fetchOptions.js");
const utils_1 = require("../internal/utils.js");
const utils_2 = require("../internal/utils.js");
const json_1 = require("../serialization/json.js");
const json_2 = require("../serialization/json.js");
const json_3 = require("../serialization/json.js");
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;
        }
    }
}
exports.CreateMetadataTaxonomyOptionals = CreateMetadataTaxonomyOptionals;
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;
        }
    }
}
exports.GetMetadataTaxonomiesOptionals = GetMetadataTaxonomiesOptionals;
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;
        }
    }
}
exports.GetMetadataTaxonomyByKeyOptionals = GetMetadataTaxonomyByKeyOptionals;
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;
        }
    }
}
exports.UpdateMetadataTaxonomyOptionals = UpdateMetadataTaxonomyOptionals;
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;
        }
    }
}
exports.DeleteMetadataTaxonomyOptionals = DeleteMetadataTaxonomyOptionals;
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;
        }
    }
}
exports.CreateMetadataTaxonomyLevelOptionals = CreateMetadataTaxonomyLevelOptionals;
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;
        }
    }
}
exports.UpdateMetadataTaxonomyLevelByIdOptionals = UpdateMetadataTaxonomyLevelByIdOptionals;
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;
        }
    }
}
exports.AddMetadataTaxonomyLevelOptionals = AddMetadataTaxonomyLevelOptionals;
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;
        }
    }
}
exports.DeleteMetadataTaxonomyLevelOptionals = DeleteMetadataTaxonomyLevelOptionals;
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;
        }
    }
}
exports.GetMetadataTaxonomyNodesOptionals = GetMetadataTaxonomyNodesOptionals;
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;
        }
    }
}
exports.CreateMetadataTaxonomyNodeOptionals = CreateMetadataTaxonomyNodeOptionals;
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;
        }
    }
}
exports.GetMetadataTaxonomyNodeByIdOptionals = GetMetadataTaxonomyNodeByIdOptionals;
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;
        }
    }
}
exports.UpdateMetadataTaxonomyNodeOptionals = UpdateMetadataTaxonomyNodeOptionals;
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;
        }
    }
}
exports.DeleteMetadataTaxonomyNodeOptionals = DeleteMetadataTaxonomyNodeOptionals;
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;
        }
    }
}
exports.GetMetadataTemplateFieldOptionsOptionals = GetMetadataTemplateFieldOptionsOptionals;
class CreateMetadataTaxonomyHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.CreateMetadataTaxonomyHeaders = CreateMetadataTaxonomyHeaders;
class GetMetadataTaxonomiesHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.GetMetadataTaxonomiesHeaders = GetMetadataTaxonomiesHeaders;
class GetMetadataTaxonomyByKeyHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.GetMetadataTaxonomyByKeyHeaders = GetMetadataTaxonomyByKeyHeaders;
class UpdateMetadataTaxonomyHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.UpdateMetadataTaxonomyHeaders = UpdateMetadataTaxonomyHeaders;
class DeleteMetadataTaxonomyHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.DeleteMetadataTaxonomyHeaders = DeleteMetadataTaxonomyHeaders;
class CreateMetadataTaxonomyLevelHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.CreateMetadataTaxonomyLevelHeaders = CreateMetadataTaxonomyLevelHeaders;
class UpdateMetadataTaxonomyLevelByIdHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.UpdateMetadataTaxonomyLevelByIdHeaders = UpdateMetadataTaxonomyLevelByIdHeaders;
class AddMetadataTaxonomyLevelHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.AddMetadataTaxonomyLevelHeaders = AddMetadataTaxonomyLevelHeaders;
class DeleteMetadataTaxonomyLevelHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.DeleteMetadataTaxonomyLevelHeaders = DeleteMetadataTaxonomyLevelHeaders;
class GetMetadataTaxonomyNodesHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.GetMetadataTaxonomyNodesHeaders = GetMetadataTaxonomyNodesHeaders;
class CreateMetadataTaxonomyNodeHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.CreateMetadataTaxonomyNodeHeaders = CreateMetadataTaxonomyNodeHeaders;
class GetMetadataTaxonomyNodeByIdHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.GetMetadataTaxonomyNodeByIdHeaders = GetMetadataTaxonomyNodeByIdHeaders;
class UpdateMetadataTaxonomyNodeHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.UpdateMetadataTaxonomyNodeHeaders = UpdateMetadataTaxonomyNodeHeaders;
class DeleteMetadataTaxonomyNodeHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.DeleteMetadataTaxonomyNodeHeaders = DeleteMetadataTaxonomyNodeHeaders;
class GetMetadataTemplateFieldOptionsHeaders {
    constructor(fields) {
        /**
         * Extra headers that will be included in the HTTP request. */
        this.extraHeaders = {};
        if (fields.extraHeaders !== undefined) {
            this.extraHeaders = fields.extraHeaders;
        }
    }
}
exports.GetMetadataTemplateFieldOptionsHeaders = GetMetadataTemplateFieldOptionsHeaders;
class MetadataTaxonomiesManager {
    constructor(fields) {
        this.networkSession = new network_1.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.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({}, (0, metadataTaxonomy_1.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(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 = (0, utils_1.prepareParams)({
                ['marker']: (0, utils_2.toString)(queryParams.marker),
                ['limit']: (0, utils_2.toString)(queryParams.limit),
            });
            const headersMap = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace)),
                method: 'GET',
                params: queryParamsMap,
                headers: headersMap,
                responseFormat: 'json',
                auth: this.auth,
                networkSession: this.networkSession,
                cancellationToken: cancellationToken,
            }));
            return Object.assign(Object.assign({}, (0, metadataTaxonomies_1.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.toString)(taxonomyKey)),
                method: 'GET',
                headers: headersMap,
                responseFormat: 'json',
                auth: this.auth,
                networkSession: this.networkSession,
                cancellationToken: cancellationToken,
            }));
            return Object.assign(Object.assign({}, (0, metadataTaxonomy_1.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.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({}, (0, metadataTaxonomy_1.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.toString)(taxonomyKey), '/levels'),
                method: 'POST',
                headers: headersMap,
                data: requestBody.map(metadataTaxonomyLevel_1.serializeMetadataTaxonomyLevel),
                contentType: 'application/json',
                responseFormat: 'json',
                auth: this.auth,
                networkSession: this.networkSession,
                cancellationToken: cancellationToken,
            }));
            return Object.assign(Object.assign({}, (0, metadataTaxonomyLevels_1.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.toString)(taxonomyKey), '/levels/', (0, utils_2.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({}, (0, metadataTaxonomyLevel_2.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.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({}, (0, metadataTaxonomyLevels_1.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.toString)(taxonomyKey), '/levels:trim'),
                method: 'POST',
                headers: headersMap,
                responseFormat: 'json',
                auth: this.auth,
                networkSession: this.networkSession,
                cancellationToken: cancellationToken,
            }));
            return Object.assign(Object.assign({}, (0, metadataTaxonomyLevels_1.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(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 = (0, utils_1.prepareParams)({
                ['level']: queryParams.level
                    ? queryParams.level.map(utils_2.toString).join(',')
                    : undefined,
                ['parent']: queryParams.parent
                    ? queryParams.parent.map(utils_2.toString).join(',')
                    : undefined,
                ['ancestor']: queryParams.ancestor
                    ? queryParams.ancestor.map(utils_2.toString).join(',')
                    : undefined,
                ['query']: (0, utils_2.toString)(queryParams.query),
                ['include-total-result-count']: (0, utils_2.toString)(queryParams.includeTotalResultCount),
                ['marker']: (0, utils_2.toString)(queryParams.marker),
                ['limit']: (0, utils_2.toString)(queryParams.limit),
            });
            const headersMap = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.toString)(taxonomyKey), '/nodes'),
                method: 'GET',
                params: queryParamsMap,
                headers: headersMap,
                responseFormat: 'json',
                auth: this.auth,
                networkSession: this.networkSession,
                cancellationToken: cancellationToken,
            }));
            return Object.assign(Object.assign({}, (0, metadataTaxonomyNodes_1.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.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({}, (0, metadataTaxonomyNode_1.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.toString)(taxonomyKey), '/nodes/', (0, utils_2.toString)(nodeId)),
                method: 'GET',
                headers: headersMap,
                responseFormat: 'json',
                auth: this.auth,
                networkSession: this.networkSession,
                cancellationToken: cancellationToken,
            }));
            return Object.assign(Object.assign({}, (0, metadataTaxonomyNode_1.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.toString)(taxonomyKey), '/nodes/', (0, utils_2.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({}, (0, metadataTaxonomyNode_1.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(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 = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_taxonomies/', (0, utils_2.toString)(namespace), '/', (0, utils_2.toString)(taxonomyKey), '/nodes/', (0, utils_2.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(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 = (0, utils_1.prepareParams)({
                ['level']: queryParams.level
                    ? queryParams.level.map(utils_2.toString).join(',')
                    : undefined,
                ['parent']: queryParams.parent
                    ? queryParams.parent.map(utils_2.toString).join(',')
                    : undefined,
                ['ancestor']: queryParams.ancestor
                    ? queryParams.ancestor.map(utils_2.toString).join(',')
                    : undefined,
                ['query']: (0, utils_2.toString)(queryParams.query),
                ['include-total-result-count']: (0, utils_2.toString)(queryParams.includeTotalResultCount),
                ['only-selectable-options']: (0, utils_2.toString)(queryParams.onlySelectableOptions),
                ['marker']: (0, utils_2.toString)(queryParams.marker),
                ['limit']: (0, utils_2.toString)(queryParams.limit),
            });
            const headersMap = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_templates/', (0, utils_2.toString)(namespace), '/', (0, utils_2.toString)(templateKey), '/fields/', (0, utils_2.toString)(fieldKey), '/options'),
                method: 'GET',
                params: queryParamsMap,
                headers: headersMap,
                responseFormat: 'json',
                auth: this.auth,
                networkSession: this.networkSession,
                cancellationToken: cancellationToken,
            }));
            return Object.assign(Object.assign({}, (0, metadataTaxonomyNodes_1.deserializeMetadataTaxonomyNodes)(response.data)), { rawData: response.data });
        });
    }
}
exports.MetadataTaxonomiesManager = MetadataTaxonomiesManager;
function serializeCreateMetadataTaxonomyRequestBody(val) {
    return {
        ['key']: val.key,
        ['displayName']: val.displayName,
        ['namespace']: val.namespace,
    };
}
function deserializeCreateMetadataTaxonomyRequestBody(val) {
    if (!(0, json_3.sdIsMap)(val)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting a map for "CreateMetadataTaxonomyRequestBody"',
        });
    }
    if (!(val.key == void 0) && !(0, json_2.sdIsString)(val.key)) {
        throw new errors_1.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 errors_1.BoxSdkError({
            message: 'Expecting "displayName" of type "CreateMetadataTaxonomyRequestBody" to be defined',
        });
    }
    if (!(0, json_2.sdIsString)(val.displayName)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting string for "displayName" of type "CreateMetadataTaxonomyRequestBody"',
        });
    }
    const displayName = val.displayName;
    if (val.namespace == void 0) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting "namespace" of type "CreateMetadataTaxonomyRequestBody" to be defined',
        });
    }
    if (!(0, json_2.sdIsString)(val.namespace)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting string for "namespace" of type "CreateMetadataTaxonomyRequestBody"',
        });
    }
    const namespace = val.namespace;
    return {
        key: key,
        displayName: displayName,
        namespace: namespace,
    };
}
function serializeUpdateMetadataTaxonomyRequestBody(val) {
    return { ['displayName']: val.displayName };
}
function deserializeUpdateMetadataTaxonomyRequestBody(val) {
    if (!(0, json_3.sdIsMap)(val)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting a map for "UpdateMetadataTaxonomyRequestBody"',
        });
    }
    if (val.displayName == void 0) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting "displayName" of type "UpdateMetadataTaxonomyRequestBody" to be defined',
        });
    }
    if (!(0, json_2.sdIsString)(val.displayName)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting string for "displayName" of type "UpdateMetadataTaxonomyRequestBody"',
        });
    }
    const displayName = val.displayName;
    return {
        displayName: displayName,
    };
}
function serializeUpdateMetadataTaxonomyLevelByIdRequestBody(val) {
    return { ['displayName']: val.displayName, ['description']: val.description };
}
function deserializeUpdateMetadataTaxonomyLevelByIdRequestBody(val) {
    if (!(0, json_3.sdIsMap)(val)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting a map for "UpdateMetadataTaxonomyLevelByIdRequestBody"',
        });
    }
    if (val.displayName == void 0) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting "displayName" of type "UpdateMetadataTaxonomyLevelByIdRequestBody" to be defined',
        });
    }
    if (!(0, json_2.sdIsString)(val.displayName)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting string for "displayName" of type "UpdateMetadataTaxonomyLevelByIdRequestBody"',
        });
    }
    const displayName = val.displayName;
    if (!(val.description == void 0) && !(0, json_2.sdIsString)(val.description)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting string for "description" of type "UpdateMetadataTaxonomyLevelByIdRequestBody"',
        });
    }
    const description = val.description == void 0 ? void 0 : val.description;
    return {
        displayName: displayName,
        description: description,
    };
}
function serializeAddMetadataTaxonomyLevelRequestBody(val) {
    return { ['displayName']: val.displayName, ['description']: val.description };
}
function deserializeAddMetadataTaxonomyLevelRequestBody(val) {
    if (!(0, json_3.sdIsMap)(val)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting a map for "AddMetadataTaxonomyLevelRequestBody"',
        });
    }
    if (val.displayName == void 0) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting "displayName" of type "AddMetadataTaxonomyLevelRequestBody" to be defined',
        });
    }
    if (!(0, json_2.sdIsString)(val.displayName)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting string for "displayName" of type "AddMetadataTaxonomyLevelRequestBody"',
        });
    }
    const displayName = val.displayName;
    if (!(val.description == void 0) && !(0, json_2.sdIsString)(val.description)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting string for "description" of type "AddMetadataTaxonomyLevelRequestBody"',
        });
    }
    const description = val.description == void 0 ? void 0 : val.description;
    return {
        displayName: displayName,
        description: description,
    };
}
function serializeCreateMetadataTaxonomyNodeRequestBody(val) {
    return {
        ['displayName']: val.displayName,
        ['level']: val.level,
        ['parentId']: val.parentId,
    };
}
function deserializeCreateMetadataTaxonomyNodeRequestBody(val) {
    if (!(0, json_3.sdIsMap)(val)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting a map for "CreateMetadataTaxonomyNodeRequestBody"',
        });
    }
    if (val.displayName == void 0) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting "displayName" of type "CreateMetadataTaxonomyNodeRequestBody" to be defined',
        });
    }
    if (!(0, json_2.sdIsString)(val.displayName)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting string for "displayName" of type "CreateMetadataTaxonomyNodeRequestBody"',
        });
    }
    const displayName = val.displayName;
    if (val.level == void 0) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting "level" of type "CreateMetadataTaxonomyNodeRequestBody" to be defined',
        });
    }
    if (!(0, json_1.sdIsNumber)(val.level)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting number for "level" of type "CreateMetadataTaxonomyNodeRequestBody"',
        });
    }
    const level = val.level;
    if (!(val.parentId == void 0) && !(0, json_2.sdIsString)(val.parentId)) {
        throw new errors_1.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,
    };
}
function serializeUpdateMetadataTaxonomyNodeRequestBody(val) {
    return { ['displayName']: val.displayName };
}
function deserializeUpdateMetadataTaxonomyNodeRequestBody(val) {
    if (!(0, json_3.sdIsMap)(val)) {
        throw new errors_1.BoxSdkError({
            message: 'Expecting a map for "UpdateMetadataTaxonomyNodeRequestBody"',
        });
    }
    if (!(val.displayName == void 0) && !(0, json_2.sdIsString)(val.displayName)) {
        throw new errors_1.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