box-node-sdk/lib/managers/metadataTaxonomies.d.ts

Official SDK for Box Platform APIs

import { MetadataTaxonomy } from '../schemas/metadataTaxonomy';
import { MetadataTaxonomies } from '../schemas/metadataTaxonomies';
import { MetadataTaxonomyLevels } from '../schemas/metadataTaxonomyLevels';
import { MetadataTaxonomyLevel } from '../schemas/metadataTaxonomyLevel';
import { MetadataTaxonomyNodes } from '../schemas/metadataTaxonomyNodes';
import { MetadataTaxonomyNode } from '../schemas/metadataTaxonomyNode';
import { Authentication } from '../networking/auth';
import { NetworkSession } from '../networking/network';
import { CancellationToken } from '../internal/utils';
import { SerializedData } from '../serialization/json';
export declare class CreateMetadataTaxonomyOptionals {
    readonly headers: CreateMetadataTaxonomyHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<CreateMetadataTaxonomyOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<CreateMetadataTaxonomyOptionals, 'headers' | 'cancellationToken'>>);
}
export interface CreateMetadataTaxonomyOptionalsInput {
    readonly headers?: CreateMetadataTaxonomyHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class GetMetadataTaxonomiesOptionals {
    readonly queryParams: GetMetadataTaxonomiesQueryParams;
    readonly headers: GetMetadataTaxonomiesHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<GetMetadataTaxonomiesOptionals, 'queryParams' | 'headers' | 'cancellationToken'> & Partial<Pick<GetMetadataTaxonomiesOptionals, 'queryParams' | 'headers' | 'cancellationToken'>>);
}
export interface GetMetadataTaxonomiesOptionalsInput {
    readonly queryParams?: GetMetadataTaxonomiesQueryParams;
    readonly headers?: GetMetadataTaxonomiesHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class GetMetadataTaxonomyByKeyOptionals {
    readonly headers: GetMetadataTaxonomyByKeyHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<GetMetadataTaxonomyByKeyOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<GetMetadataTaxonomyByKeyOptionals, 'headers' | 'cancellationToken'>>);
}
export interface GetMetadataTaxonomyByKeyOptionalsInput {
    readonly headers?: GetMetadataTaxonomyByKeyHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class UpdateMetadataTaxonomyOptionals {
    readonly headers: UpdateMetadataTaxonomyHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<UpdateMetadataTaxonomyOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<UpdateMetadataTaxonomyOptionals, 'headers' | 'cancellationToken'>>);
}
export interface UpdateMetadataTaxonomyOptionalsInput {
    readonly headers?: UpdateMetadataTaxonomyHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class DeleteMetadataTaxonomyOptionals {
    readonly headers: DeleteMetadataTaxonomyHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<DeleteMetadataTaxonomyOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<DeleteMetadataTaxonomyOptionals, 'headers' | 'cancellationToken'>>);
}
export interface DeleteMetadataTaxonomyOptionalsInput {
    readonly headers?: DeleteMetadataTaxonomyHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class CreateMetadataTaxonomyLevelOptionals {
    readonly headers: CreateMetadataTaxonomyLevelHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<CreateMetadataTaxonomyLevelOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<CreateMetadataTaxonomyLevelOptionals, 'headers' | 'cancellationToken'>>);
}
export interface CreateMetadataTaxonomyLevelOptionalsInput {
    readonly headers?: CreateMetadataTaxonomyLevelHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class UpdateMetadataTaxonomyLevelByIdOptionals {
    readonly headers: UpdateMetadataTaxonomyLevelByIdHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<UpdateMetadataTaxonomyLevelByIdOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<UpdateMetadataTaxonomyLevelByIdOptionals, 'headers' | 'cancellationToken'>>);
}
export interface UpdateMetadataTaxonomyLevelByIdOptionalsInput {
    readonly headers?: UpdateMetadataTaxonomyLevelByIdHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class AddMetadataTaxonomyLevelOptionals {
    readonly headers: AddMetadataTaxonomyLevelHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<AddMetadataTaxonomyLevelOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<AddMetadataTaxonomyLevelOptionals, 'headers' | 'cancellationToken'>>);
}
export interface AddMetadataTaxonomyLevelOptionalsInput {
    readonly headers?: AddMetadataTaxonomyLevelHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class DeleteMetadataTaxonomyLevelOptionals {
    readonly headers: DeleteMetadataTaxonomyLevelHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<DeleteMetadataTaxonomyLevelOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<DeleteMetadataTaxonomyLevelOptionals, 'headers' | 'cancellationToken'>>);
}
export interface DeleteMetadataTaxonomyLevelOptionalsInput {
    readonly headers?: DeleteMetadataTaxonomyLevelHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class GetMetadataTaxonomyNodesOptionals {
    readonly queryParams: GetMetadataTaxonomyNodesQueryParams;
    readonly headers: GetMetadataTaxonomyNodesHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<GetMetadataTaxonomyNodesOptionals, 'queryParams' | 'headers' | 'cancellationToken'> & Partial<Pick<GetMetadataTaxonomyNodesOptionals, 'queryParams' | 'headers' | 'cancellationToken'>>);
}
export interface GetMetadataTaxonomyNodesOptionalsInput {
    readonly queryParams?: GetMetadataTaxonomyNodesQueryParams;
    readonly headers?: GetMetadataTaxonomyNodesHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class CreateMetadataTaxonomyNodeOptionals {
    readonly headers: CreateMetadataTaxonomyNodeHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<CreateMetadataTaxonomyNodeOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<CreateMetadataTaxonomyNodeOptionals, 'headers' | 'cancellationToken'>>);
}
export interface CreateMetadataTaxonomyNodeOptionalsInput {
    readonly headers?: CreateMetadataTaxonomyNodeHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class GetMetadataTaxonomyNodeByIdOptionals {
    readonly headers: GetMetadataTaxonomyNodeByIdHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<GetMetadataTaxonomyNodeByIdOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<GetMetadataTaxonomyNodeByIdOptionals, 'headers' | 'cancellationToken'>>);
}
export interface GetMetadataTaxonomyNodeByIdOptionalsInput {
    readonly headers?: GetMetadataTaxonomyNodeByIdHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class UpdateMetadataTaxonomyNodeOptionals {
    readonly requestBody: UpdateMetadataTaxonomyNodeRequestBody;
    readonly headers: UpdateMetadataTaxonomyNodeHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<UpdateMetadataTaxonomyNodeOptionals, 'requestBody' | 'headers' | 'cancellationToken'> & Partial<Pick<UpdateMetadataTaxonomyNodeOptionals, 'requestBody' | 'headers' | 'cancellationToken'>>);
}
export interface UpdateMetadataTaxonomyNodeOptionalsInput {
    readonly requestBody?: UpdateMetadataTaxonomyNodeRequestBody;
    readonly headers?: UpdateMetadataTaxonomyNodeHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class DeleteMetadataTaxonomyNodeOptionals {
    readonly headers: DeleteMetadataTaxonomyNodeHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<DeleteMetadataTaxonomyNodeOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<DeleteMetadataTaxonomyNodeOptionals, 'headers' | 'cancellationToken'>>);
}
export interface DeleteMetadataTaxonomyNodeOptionalsInput {
    readonly headers?: DeleteMetadataTaxonomyNodeHeaders;
    readonly cancellationToken?: CancellationToken;
}
export declare class GetMetadataTemplateFieldOptionsOptionals {
    readonly queryParams: GetMetadataTemplateFieldOptionsQueryParams;
    readonly headers: GetMetadataTemplateFieldOptionsHeaders;
    readonly cancellationToken?: CancellationToken;
    constructor(fields: Omit<GetMetadataTemplateFieldOptionsOptionals, 'queryParams' | 'headers' | 'cancellationToken'> & Partial<Pick<GetMetadataTemplateFieldOptionsOptionals, 'queryParams' | 'headers' | 'cancellationToken'>>);
}
export interface GetMetadataTemplateFieldOptionsOptionalsInput {
    readonly queryParams?: GetMetadataTemplateFieldOptionsQueryParams;
    readonly headers?: GetMetadataTemplateFieldOptionsHeaders;
    readonly cancellationToken?: CancellationToken;
}
export interface CreateMetadataTaxonomyRequestBody {
    /**
     * The taxonomy key. If it is not provided in the request body, it will be
     * generated from the `displayName`. The `displayName` would be converted
     * to lower case, and all spaces and non-alphanumeric characters replaced
     * with underscores. */
    readonly key?: string;
    /**
     * The display name of the taxonomy. */
    readonly displayName: string;
    /**
     * The namespace of the metadata taxonomy to create. */
    readonly namespace: string;
    readonly rawData?: SerializedData;
}
export declare class CreateMetadataTaxonomyHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<CreateMetadataTaxonomyHeaders, 'extraHeaders'> & Partial<Pick<CreateMetadataTaxonomyHeaders, 'extraHeaders'>>);
}
export interface CreateMetadataTaxonomyHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export interface GetMetadataTaxonomiesQueryParams {
    /**
     * Defines the position marker at which to begin returning results. This is
     * used when paginating using marker-based pagination.
     *
     * This requires `usemarker` to be set to `true`. */
    readonly marker?: string;
    /**
     * The maximum number of items to return per page. */
    readonly limit?: number;
}
export declare class GetMetadataTaxonomiesHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<GetMetadataTaxonomiesHeaders, 'extraHeaders'> & Partial<Pick<GetMetadataTaxonomiesHeaders, 'extraHeaders'>>);
}
export interface GetMetadataTaxonomiesHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export declare class GetMetadataTaxonomyByKeyHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<GetMetadataTaxonomyByKeyHeaders, 'extraHeaders'> & Partial<Pick<GetMetadataTaxonomyByKeyHeaders, 'extraHeaders'>>);
}
export interface GetMetadataTaxonomyByKeyHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export interface UpdateMetadataTaxonomyRequestBody {
    /**
     * The display name of the taxonomy. */
    readonly displayName: string;
    readonly rawData?: SerializedData;
}
export declare class UpdateMetadataTaxonomyHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<UpdateMetadataTaxonomyHeaders, 'extraHeaders'> & Partial<Pick<UpdateMetadataTaxonomyHeaders, 'extraHeaders'>>);
}
export interface UpdateMetadataTaxonomyHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export declare class DeleteMetadataTaxonomyHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<DeleteMetadataTaxonomyHeaders, 'extraHeaders'> & Partial<Pick<DeleteMetadataTaxonomyHeaders, 'extraHeaders'>>);
}
export interface DeleteMetadataTaxonomyHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export declare class CreateMetadataTaxonomyLevelHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<CreateMetadataTaxonomyLevelHeaders, 'extraHeaders'> & Partial<Pick<CreateMetadataTaxonomyLevelHeaders, 'extraHeaders'>>);
}
export interface CreateMetadataTaxonomyLevelHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export interface UpdateMetadataTaxonomyLevelByIdRequestBody {
    /**
     * The display name of the taxonomy level. */
    readonly displayName: string;
    /**
     * The description of the taxonomy level. */
    readonly description?: string;
    readonly rawData?: SerializedData;
}
export declare class UpdateMetadataTaxonomyLevelByIdHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<UpdateMetadataTaxonomyLevelByIdHeaders, 'extraHeaders'> & Partial<Pick<UpdateMetadataTaxonomyLevelByIdHeaders, 'extraHeaders'>>);
}
export interface UpdateMetadataTaxonomyLevelByIdHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export interface AddMetadataTaxonomyLevelRequestBody {
    /**
     * The display name of the taxonomy level. */
    readonly displayName: string;
    /**
     * The description of the taxonomy level. */
    readonly description?: string;
    readonly rawData?: SerializedData;
}
export declare class AddMetadataTaxonomyLevelHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<AddMetadataTaxonomyLevelHeaders, 'extraHeaders'> & Partial<Pick<AddMetadataTaxonomyLevelHeaders, 'extraHeaders'>>);
}
export interface AddMetadataTaxonomyLevelHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export declare class DeleteMetadataTaxonomyLevelHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<DeleteMetadataTaxonomyLevelHeaders, 'extraHeaders'> & Partial<Pick<DeleteMetadataTaxonomyLevelHeaders, 'extraHeaders'>>);
}
export interface DeleteMetadataTaxonomyLevelHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export interface GetMetadataTaxonomyNodesQueryParams {
    /**
     * Filters results by taxonomy level. Multiple values can be provided.
     * Results include nodes that match any of the specified values. */
    readonly level?: readonly number[];
    /**
     * Node identifier of a direct parent node. Multiple values can be provided.
     * Results include nodes that match any of the specified values. */
    readonly parent?: readonly string[];
    /**
     * Node identifier of any ancestor node. Multiple values can be provided.
     * Results include nodes that match any of the specified values. */
    readonly ancestor?: readonly string[];
    /**
     * Query text to search for the taxonomy nodes. */
    readonly query?: string;
    /**
     * When set to `true` this provides the total number of nodes that matched the query.
     * The response will compute counts of up to 10,000 elements. Defaults to `false`. */
    readonly includeTotalResultCount?: boolean;
    /**
     * Defines the position marker at which to begin returning results. This is
     * used when paginating using marker-based pagination.
     *
     * This requires `usemarker` to be set to `true`. */
    readonly marker?: string;
    /**
     * The maximum number of items to return per page. */
    readonly limit?: number;
}
export declare class GetMetadataTaxonomyNodesHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<GetMetadataTaxonomyNodesHeaders, 'extraHeaders'> & Partial<Pick<GetMetadataTaxonomyNodesHeaders, 'extraHeaders'>>);
}
export interface GetMetadataTaxonomyNodesHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export interface CreateMetadataTaxonomyNodeRequestBody {
    /**
     * The display name of the taxonomy node. */
    readonly displayName: string;
    /**
     * The level of the taxonomy node. */
    readonly level: number;
    /**
     * The identifier of the parent taxonomy node.
     * Omit this field for root-level nodes. */
    readonly parentId?: string;
    readonly rawData?: SerializedData;
}
export declare class CreateMetadataTaxonomyNodeHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<CreateMetadataTaxonomyNodeHeaders, 'extraHeaders'> & Partial<Pick<CreateMetadataTaxonomyNodeHeaders, 'extraHeaders'>>);
}
export interface CreateMetadataTaxonomyNodeHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export declare class GetMetadataTaxonomyNodeByIdHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<GetMetadataTaxonomyNodeByIdHeaders, 'extraHeaders'> & Partial<Pick<GetMetadataTaxonomyNodeByIdHeaders, 'extraHeaders'>>);
}
export interface GetMetadataTaxonomyNodeByIdHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export interface UpdateMetadataTaxonomyNodeRequestBody {
    /**
     * The display name of the taxonomy node. */
    readonly displayName?: string;
    readonly rawData?: SerializedData;
}
export declare class UpdateMetadataTaxonomyNodeHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<UpdateMetadataTaxonomyNodeHeaders, 'extraHeaders'> & Partial<Pick<UpdateMetadataTaxonomyNodeHeaders, 'extraHeaders'>>);
}
export interface UpdateMetadataTaxonomyNodeHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export declare class DeleteMetadataTaxonomyNodeHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<DeleteMetadataTaxonomyNodeHeaders, 'extraHeaders'> & Partial<Pick<DeleteMetadataTaxonomyNodeHeaders, 'extraHeaders'>>);
}
export interface DeleteMetadataTaxonomyNodeHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export interface GetMetadataTemplateFieldOptionsQueryParams {
    /**
     * Filters results by taxonomy level. Multiple values can be provided.
     * Results include nodes that match any of the specified values. */
    readonly level?: readonly number[];
    /**
     * Node identifier of a direct parent node. Multiple values can be provided.
     * Results include nodes that match any of the specified values. */
    readonly parent?: readonly string[];
    /**
     * Node identifier of any ancestor node. Multiple values can be provided.
     * Results include nodes that match any of the specified values. */
    readonly ancestor?: readonly string[];
    /**
     * Query text to search for the taxonomy nodes. */
    readonly query?: string;
    /**
     * When set to `true` this provides the total number of nodes that matched the query.
     * The response will compute counts of up to 10,000 elements. Defaults to `false`. */
    readonly includeTotalResultCount?: boolean;
    /**
     * When set to `true`, this only returns valid selectable options for this template
     * taxonomy field. Otherwise, it returns all taxonomy nodes, whether or not they are selectable.
     * Defaults to `true`. */
    readonly onlySelectableOptions?: boolean;
    /**
     * Defines the position marker at which to begin returning results. This is
     * used when paginating using marker-based pagination.
     *
     * This requires `usemarker` to be set to `true`. */
    readonly marker?: string;
    /**
     * The maximum number of items to return per page. */
    readonly limit?: number;
}
export declare class GetMetadataTemplateFieldOptionsHeaders {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
    constructor(fields: Omit<GetMetadataTemplateFieldOptionsHeaders, 'extraHeaders'> & Partial<Pick<GetMetadataTemplateFieldOptionsHeaders, 'extraHeaders'>>);
}
export interface GetMetadataTemplateFieldOptionsHeadersInput {
    /**
     * Extra headers that will be included in the HTTP request. */
    readonly extraHeaders?: {
        readonly [key: string]: undefined | string;
    };
}
export declare class MetadataTaxonomiesManager {
    readonly auth?: Authentication;
    readonly networkSession: NetworkSession;
    constructor(fields: Omit<MetadataTaxonomiesManager, 'networkSession' | 'createMetadataTaxonomy' | 'getMetadataTaxonomies' | 'getMetadataTaxonomyByKey' | 'updateMetadataTaxonomy' | 'deleteMetadataTaxonomy' | 'createMetadataTaxonomyLevel' | 'updateMetadataTaxonomyLevelById' | 'addMetadataTaxonomyLevel' | 'deleteMetadataTaxonomyLevel' | 'getMetadataTaxonomyNodes' | 'createMetadataTaxonomyNode' | 'getMetadataTaxonomyNodeById' | 'updateMetadataTaxonomyNode' | 'deleteMetadataTaxonomyNode' | 'getMetadataTemplateFieldOptions'> & Partial<Pick<MetadataTaxonomiesManager, '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: CreateMetadataTaxonomyRequestBody, optionalsInput?: CreateMetadataTaxonomyOptionalsInput): Promise<MetadataTaxonomy>;
    /**
       * 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: string, optionalsInput?: GetMetadataTaxonomiesOptionalsInput): Promise<MetadataTaxonomies>;
    /**
       * 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: string, taxonomyKey: string, optionalsInput?: GetMetadataTaxonomyByKeyOptionalsInput): Promise<MetadataTaxonomy>;
    /**
       * 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: string, taxonomyKey: string, requestBody: UpdateMetadataTaxonomyRequestBody, optionalsInput?: UpdateMetadataTaxonomyOptionalsInput): Promise<MetadataTaxonomy>;
    /**
       * 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: string, taxonomyKey: string, optionalsInput?: DeleteMetadataTaxonomyOptionalsInput): Promise<undefined>;
    /**
       * 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: string, taxonomyKey: string, requestBody: readonly MetadataTaxonomyLevel[], optionalsInput?: CreateMetadataTaxonomyLevelOptionalsInput): Promise<MetadataTaxonomyLevels>;
    /**
       * 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: string, taxonomyKey: string, levelIndex: number, requestBody: UpdateMetadataTaxonomyLevelByIdRequestBody, optionalsInput?: UpdateMetadataTaxonomyLevelByIdOptionalsInput): Promise<MetadataTaxonomyLevel>;
    /**
       * 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: string, taxonomyKey: string, requestBody: AddMetadataTaxonomyLevelRequestBody, optionalsInput?: AddMetadataTaxonomyLevelOptionalsInput): Promise<MetadataTaxonomyLevels>;
    /**
       * 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: string, taxonomyKey: string, optionalsInput?: DeleteMetadataTaxonomyLevelOptionalsInput): Promise<MetadataTaxonomyLevels>;
    /**
       * 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: string, taxonomyKey: string, optionalsInput?: GetMetadataTaxonomyNodesOptionalsInput): Promise<MetadataTaxonomyNodes>;
    /**
       * 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: string, taxonomyKey: string, requestBody: CreateMetadataTaxonomyNodeRequestBody, optionalsInput?: CreateMetadataTaxonomyNodeOptionalsInput): Promise<MetadataTaxonomyNode>;
    /**
       * 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: string, taxonomyKey: string, nodeId: string, optionalsInput?: GetMetadataTaxonomyNodeByIdOptionalsInput): Promise<MetadataTaxonomyNode>;
    /**
       * 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: string, taxonomyKey: string, nodeId: string, optionalsInput?: UpdateMetadataTaxonomyNodeOptionalsInput): Promise<MetadataTaxonomyNode>;
    /**
       * 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: string, taxonomyKey: string, nodeId: string, optionalsInput?: DeleteMetadataTaxonomyNodeOptionalsInput): Promise<undefined>;
    /**
       * 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: string, templateKey: string, fieldKey: string, optionalsInput?: GetMetadataTemplateFieldOptionsOptionalsInput): Promise<MetadataTaxonomyNodes>;
}
export interface MetadataTaxonomiesManagerInput {
    readonly auth?: Authentication;
    readonly networkSession?: NetworkSession;
}
export declare function serializeCreateMetadataTaxonomyRequestBody(val: CreateMetadataTaxonomyRequestBody): SerializedData;
export declare function deserializeCreateMetadataTaxonomyRequestBody(val: SerializedData): CreateMetadataTaxonomyRequestBody;
export declare function serializeUpdateMetadataTaxonomyRequestBody(val: UpdateMetadataTaxonomyRequestBody): SerializedData;
export declare function deserializeUpdateMetadataTaxonomyRequestBody(val: SerializedData): UpdateMetadataTaxonomyRequestBody;
export declare function serializeUpdateMetadataTaxonomyLevelByIdRequestBody(val: UpdateMetadataTaxonomyLevelByIdRequestBody): SerializedData;
export declare function deserializeUpdateMetadataTaxonomyLevelByIdRequestBody(val: SerializedData): UpdateMetadataTaxonomyLevelByIdRequestBody;
export declare function serializeAddMetadataTaxonomyLevelRequestBody(val: AddMetadataTaxonomyLevelRequestBody): SerializedData;
export declare function deserializeAddMetadataTaxonomyLevelRequestBody(val: SerializedData): AddMetadataTaxonomyLevelRequestBody;
export declare function serializeCreateMetadataTaxonomyNodeRequestBody(val: CreateMetadataTaxonomyNodeRequestBody): SerializedData;
export declare function deserializeCreateMetadataTaxonomyNodeRequestBody(val: SerializedData): CreateMetadataTaxonomyNodeRequestBody;
export declare function serializeUpdateMetadataTaxonomyNodeRequestBody(val: UpdateMetadataTaxonomyNodeRequestBody): SerializedData;
export declare function deserializeUpdateMetadataTaxonomyNodeRequestBody(val: SerializedData): UpdateMetadataTaxonomyNodeRequestBody;
//# sourceMappingURL=metadataTaxonomies.d.ts.map