box-node-sdk 10.2.0 → 10.4.0

package/lib/managers/metadataTaxonomies.d.ts

@@ -0,0 +1,704 @@
+import { MetadataTaxonomy } from '../schemas/metadataTaxonomy.js';
+import { MetadataTaxonomies } from '../schemas/metadataTaxonomies.js';
+import { MetadataTaxonomyLevels } from '../schemas/metadataTaxonomyLevels.js';
+import { MetadataTaxonomyLevel } from '../schemas/metadataTaxonomyLevel.js';
+import { MetadataTaxonomyNodes } from '../schemas/metadataTaxonomyNodes.js';
+import { MetadataTaxonomyNode } from '../schemas/metadataTaxonomyNode.js';
+import { Authentication } from '../networking/auth.js';
+import { NetworkSession } from '../networking/network.js';
+import { CancellationToken } from '../internal/utils.js';
+import { SerializedData } from '../serialization/json.js';
+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