box-node-sdk/lib-esm/managers/metadataTaxonomies.js

Official SDK for Box Platform APIs

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