box-node-sdk
Version:
Official SDK for Box Platform APIs
973 lines (972 loc) • 57.1 kB
JavaScript
"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");
const metadataTaxonomies_1 = require("../schemas/metadataTaxonomies");
const metadataTaxonomyLevels_1 = require("../schemas/metadataTaxonomyLevels");
const metadataTaxonomyLevel_1 = require("../schemas/metadataTaxonomyLevel");
const metadataTaxonomyLevel_2 = require("../schemas/metadataTaxonomyLevel");
const metadataTaxonomyNodes_1 = require("../schemas/metadataTaxonomyNodes");
const metadataTaxonomyNode_1 = require("../schemas/metadataTaxonomyNode");
const errors_1 = require("../box/errors");
const network_1 = require("../networking/network");
const fetchOptions_1 = require("../networking/fetchOptions");
const utils_1 = require("../internal/utils");
const utils_2 = require("../internal/utils");
const json_1 = require("../serialization/json");
const json_2 = require("../serialization/json");
const json_3 = require("../serialization/json");
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({