box-node-sdk 10.2.0 → 10.3.0

package/src/schemas/templateSignerInput.ts

@@ -1,9 +1,45 @@
 import { serializeDate } from '../internal/utils';
 import { deserializeDate } from '../internal/utils';
+import { serializeSignRequestSignerInputEmailValidation } from './signRequestSignerInputEmailValidation';
+import { deserializeSignRequestSignerInputEmailValidation } from './signRequestSignerInputEmailValidation';
+import { serializeSignRequestSignerInputCustomValidation } from './signRequestSignerInputCustomValidation';
+import { deserializeSignRequestSignerInputCustomValidation } from './signRequestSignerInputCustomValidation';
+import { serializeSignRequestSignerInputZipValidation } from './signRequestSignerInputZipValidation';
+import { deserializeSignRequestSignerInputZipValidation } from './signRequestSignerInputZipValidation';
+import { serializeSignRequestSignerInputZip4Validation } from './signRequestSignerInputZip4Validation';
+import { deserializeSignRequestSignerInputZip4Validation } from './signRequestSignerInputZip4Validation';
+import { serializeSignRequestSignerInputSsnValidation } from './signRequestSignerInputSsnValidation';
+import { deserializeSignRequestSignerInputSsnValidation } from './signRequestSignerInputSsnValidation';
+import { serializeSignRequestSignerInputNumberWithPeriodValidation } from './signRequestSignerInputNumberWithPeriodValidation';
+import { deserializeSignRequestSignerInputNumberWithPeriodValidation } from './signRequestSignerInputNumberWithPeriodValidation';
+import { serializeSignRequestSignerInputNumberWithCommaValidation } from './signRequestSignerInputNumberWithCommaValidation';
+import { deserializeSignRequestSignerInputNumberWithCommaValidation } from './signRequestSignerInputNumberWithCommaValidation';
+import { serializeSignRequestSignerInputDateIsoValidation } from './signRequestSignerInputDateIsoValidation';
+import { deserializeSignRequestSignerInputDateIsoValidation } from './signRequestSignerInputDateIsoValidation';
+import { serializeSignRequestSignerInputDateUsValidation } from './signRequestSignerInputDateUsValidation';
+import { deserializeSignRequestSignerInputDateUsValidation } from './signRequestSignerInputDateUsValidation';
+import { serializeSignRequestSignerInputDateEuValidation } from './signRequestSignerInputDateEuValidation';
+import { deserializeSignRequestSignerInputDateEuValidation } from './signRequestSignerInputDateEuValidation';
+import { serializeSignRequestSignerInputDateAsiaValidation } from './signRequestSignerInputDateAsiaValidation';
+import { deserializeSignRequestSignerInputDateAsiaValidation } from './signRequestSignerInputDateAsiaValidation';
 import { serializeSignRequestPrefillTag } from './signRequestPrefillTag';
 import { deserializeSignRequestPrefillTag } from './signRequestPrefillTag';
+import { serializeSignRequestSignerInputValidation } from './signRequestSignerInputValidation';
+import { deserializeSignRequestSignerInputValidation } from './signRequestSignerInputValidation';
 import { Date } from '../internal/utils';
+import { SignRequestSignerInputEmailValidation } from './signRequestSignerInputEmailValidation';
+import { SignRequestSignerInputCustomValidation } from './signRequestSignerInputCustomValidation';
+import { SignRequestSignerInputZipValidation } from './signRequestSignerInputZipValidation';
+import { SignRequestSignerInputZip4Validation } from './signRequestSignerInputZip4Validation';
+import { SignRequestSignerInputSsnValidation } from './signRequestSignerInputSsnValidation';
+import { SignRequestSignerInputNumberWithPeriodValidation } from './signRequestSignerInputNumberWithPeriodValidation';
+import { SignRequestSignerInputNumberWithCommaValidation } from './signRequestSignerInputNumberWithCommaValidation';
+import { SignRequestSignerInputDateIsoValidation } from './signRequestSignerInputDateIsoValidation';
+import { SignRequestSignerInputDateUsValidation } from './signRequestSignerInputDateUsValidation';
+import { SignRequestSignerInputDateEuValidation } from './signRequestSignerInputDateEuValidation';
+import { SignRequestSignerInputDateAsiaValidation } from './signRequestSignerInputDateAsiaValidation';
 import { SignRequestPrefillTag } from './signRequestPrefillTag';
+import { SignRequestSignerInputValidation } from './signRequestSignerInputValidation';
 import { BoxSdkError } from '../box/errors';
 import { SerializedData } from '../serialization/json';
 import { sdIsEmpty } from '../serialization/json';
@@ -90,8 +126,12 @@ export type TemplateSignerInput = SignRequestPrefillTag & {
    * The label field is used especially for text, attachment, radio, and checkbox type inputs. */
   readonly label?: string | null;
   /**
-   * Whether this input was defined as read-only(immutable by signers) or not. */
+   * Indicates whether this input is read-only (cannot be modified by signers). */
   readonly readOnly?: boolean;
+  /**
+   * Specifies the formatting rules that signers must follow for text field inputs.
+   * If set, this validation is mandatory. */
+  readonly validation?: SignRequestSignerInputValidation;
 };
 export function serializeTemplateSignerInputTypeField(
   val: TemplateSignerInputTypeField,
@@ -287,6 +327,10 @@ export function serializeTemplateSignerInput(
           : serializeTemplateSignerInputDimensionsField(val.dimensions),
       ['label']: val.label,
       ['read_only']: val.readOnly,
+      ['validation']:
+        val.validation == void 0
+          ? val.validation
+          : serializeSignRequestSignerInputValidation(val.validation),
     },
   };
 }
@@ -383,6 +427,10 @@ export function deserializeTemplateSignerInput(
   }
   const readOnly: undefined | boolean =
     val.read_only == void 0 ? void 0 : val.read_only;
+  const validation: SignRequestSignerInputValidation | undefined =
+    val.validation == void 0
+      ? void 0
+      : deserializeSignRequestSignerInputValidation(val.validation);
   if (!(val.document_tag_id == void 0) && !sdIsString(val.document_tag_id)) {
     throw new BoxSdkError({
       message:
@@ -427,6 +475,7 @@ export function deserializeTemplateSignerInput(
     dimensions: dimensions,
     label: label,
     readOnly: readOnly,
+    validation: validation,
     documentTagId: documentTagId,
     textValue: textValue,
     checkboxValue: checkboxValue,

package/src/test/docgen.test.ts

@@ -1,5 +1,7 @@
 import { serializeFileFull } from '@/schemas/fileFull';
 import { deserializeFileFull } from '@/schemas/fileFull';
+import { serializeUpdateFileByIdRequestBody } from '@/managers/files';
+import { deserializeUpdateFileByIdRequestBody } from '@/managers/files';
 import { serializeFolderFull } from '@/schemas/folderFull';
 import { deserializeFolderFull } from '@/schemas/folderFull';
 import { serializeDocGenTemplateBaseV2025R0 } from '@/schemas/v2025R0/docGenTemplateBaseV2025R0';
@@ -24,8 +26,11 @@ import { serializeDocGenJobFullV2025R0 } from '@/schemas/v2025R0/docGenJobFullV2
 import { deserializeDocGenJobFullV2025R0 } from '@/schemas/v2025R0/docGenJobFullV2025R0';
 import { serializeDocGenJobV2025R0 } from '@/schemas/v2025R0/docGenJobV2025R0';
 import { deserializeDocGenJobV2025R0 } from '@/schemas/v2025R0/docGenJobV2025R0';
+import { UpdateFileByIdOptionalsInput } from '@/managers/files';
+import { UpdateFileByIdOptionals } from '@/managers/files';
 import { BoxClient } from '@/client';
 import { FileFull } from '@/schemas/fileFull';
+import { UpdateFileByIdRequestBody } from '@/managers/files';
 import { FolderFull } from '@/schemas/folderFull';
 import { DocGenTemplateBaseV2025R0 } from '@/schemas/v2025R0/docGenTemplateBaseV2025R0';
 import { DocGenTemplateCreateRequestV2025R0 } from '@/schemas/v2025R0/docGenTemplateCreateRequestV2025R0';
@@ -53,15 +58,23 @@ import { sdIsList } from '@/serialization/json';
 import { sdIsMap } from '@/serialization/json';
 export const client: BoxClient = getDefaultClient();
 test('testDocgenBatchAndJobs', async function testDocgenBatchAndJobs(): Promise<any> {
-  const uploadedFile: FileFull = await uploadNewFile();
+  const uploadedFilePdf: FileFull = await uploadNewFile();
+  const uploadedFileDocx: FileFull = await client.files.updateFileById(
+    uploadedFilePdf.id,
+    {
+      requestBody: {
+        name: ''.concat(uploadedFilePdf.name!, '.docx') as string,
+      } satisfies UpdateFileByIdRequestBody,
+    } satisfies UpdateFileByIdOptionalsInput,
+  );
   const folder: FolderFull = await createNewFolder();
   const createdDocgenTemplate: DocGenTemplateBaseV2025R0 =
     await client.docgenTemplate.createDocgenTemplateV2025R0({
-      file: new FileReferenceV2025R0({ id: uploadedFile.id }),
+      file: new FileReferenceV2025R0({ id: uploadedFileDocx.id }),
     } satisfies DocGenTemplateCreateRequestV2025R0);
   const docgenBatch: DocGenBatchBaseV2025R0 =
     await client.docgen.createDocgenBatchV2025R0({
-      file: new FileReferenceV2025R0({ id: uploadedFile.id }),
+      file: new FileReferenceV2025R0({ id: uploadedFileDocx.id }),
       inputSource: 'api',
       destinationFolder:
         new DocGenBatchCreateRequestV2025R0DestinationFolderField({
@@ -100,7 +113,7 @@ test('testDocgenBatchAndJobs', async function testDocgenBatchAndJobs(): Promise<
   if (!!((toString(docgenBatchJobs.entries![0].status) as string) == '')) {
     throw new Error('Assertion failed');
   }
-  if (!(docgenBatchJobs.entries![0].templateFile.id == uploadedFile.id)) {
+  if (!(docgenBatchJobs.entries![0].templateFile.id == uploadedFileDocx.id)) {
     throw new Error('Assertion failed');
   }
   if (!(docgenBatchJobs.entries![0].batch.id == docgenBatch.id)) {
@@ -193,6 +206,6 @@ test('testDocgenBatchAndJobs', async function testDocgenBatchAndJobs(): Promise<
     throw new Error('Assertion failed');
   }
   await client.folders.deleteFolderById(folder.id);
-  await client.files.deleteFileById(uploadedFile.id);
+  await client.files.deleteFileById(uploadedFileDocx.id);
 });
 export {};

package/src/test/metadataTaxonomies.test.ts

@@ -0,0 +1,392 @@
+import { serializeMetadataTaxonomy } from '@/schemas/metadataTaxonomy';
+import { deserializeMetadataTaxonomy } from '@/schemas/metadataTaxonomy';
+import { serializeCreateMetadataTaxonomyRequestBody } from '@/managers/metadataTaxonomies';
+import { deserializeCreateMetadataTaxonomyRequestBody } from '@/managers/metadataTaxonomies';
+import { serializeMetadataTaxonomies } from '@/schemas/metadataTaxonomies';
+import { deserializeMetadataTaxonomies } from '@/schemas/metadataTaxonomies';
+import { serializeUpdateMetadataTaxonomyRequestBody } from '@/managers/metadataTaxonomies';
+import { deserializeUpdateMetadataTaxonomyRequestBody } from '@/managers/metadataTaxonomies';
+import { serializeMetadataTaxonomyLevels } from '@/schemas/metadataTaxonomyLevels';
+import { deserializeMetadataTaxonomyLevels } from '@/schemas/metadataTaxonomyLevels';
+import { serializeMetadataTaxonomyLevel } from '@/schemas/metadataTaxonomyLevel';
+import { deserializeMetadataTaxonomyLevel } from '@/schemas/metadataTaxonomyLevel';
+import { serializeUpdateMetadataTaxonomyLevelByIdRequestBody } from '@/managers/metadataTaxonomies';
+import { deserializeUpdateMetadataTaxonomyLevelByIdRequestBody } from '@/managers/metadataTaxonomies';
+import { serializeAddMetadataTaxonomyLevelRequestBody } from '@/managers/metadataTaxonomies';
+import { deserializeAddMetadataTaxonomyLevelRequestBody } from '@/managers/metadataTaxonomies';
+import { serializeMetadataTaxonomyNode } from '@/schemas/metadataTaxonomyNode';
+import { deserializeMetadataTaxonomyNode } from '@/schemas/metadataTaxonomyNode';
+import { serializeCreateMetadataTaxonomyNodeRequestBody } from '@/managers/metadataTaxonomies';
+import { deserializeCreateMetadataTaxonomyNodeRequestBody } from '@/managers/metadataTaxonomies';
+import { serializeMetadataTaxonomyNodes } from '@/schemas/metadataTaxonomyNodes';
+import { deserializeMetadataTaxonomyNodes } from '@/schemas/metadataTaxonomyNodes';
+import { serializeUpdateMetadataTaxonomyNodeRequestBody } from '@/managers/metadataTaxonomies';
+import { deserializeUpdateMetadataTaxonomyNodeRequestBody } from '@/managers/metadataTaxonomies';
+import { serializeMetadataTemplate } from '@/schemas/metadataTemplate';
+import { deserializeMetadataTemplate } from '@/schemas/metadataTemplate';
+import { serializeCreateMetadataTemplateRequestBody } from '@/managers/metadataTemplates';
+import { deserializeCreateMetadataTemplateRequestBody } from '@/managers/metadataTemplates';
+import { serializeCreateMetadataTemplateRequestBodyFieldsField } from '@/managers/metadataTemplates';
+import { deserializeCreateMetadataTemplateRequestBodyFieldsField } from '@/managers/metadataTemplates';
+import { serializeCreateMetadataTemplateRequestBodyFieldsTypeField } from '@/managers/metadataTemplates';
+import { deserializeCreateMetadataTemplateRequestBodyFieldsTypeField } from '@/managers/metadataTemplates';
+import { serializeCreateMetadataTemplateRequestBodyFieldsOptionsRulesField } from '@/managers/metadataTemplates';
+import { deserializeCreateMetadataTemplateRequestBodyFieldsOptionsRulesField } from '@/managers/metadataTemplates';
+import { serializeDeleteMetadataTemplateScope } from '@/managers/metadataTemplates';
+import { deserializeDeleteMetadataTemplateScope } from '@/managers/metadataTemplates';
+import { UpdateMetadataTaxonomyNodeOptionalsInput } from '@/managers/metadataTaxonomies';
+import { UpdateMetadataTaxonomyNodeOptionals } from '@/managers/metadataTaxonomies';
+import { BoxClient } from '@/client';
+import { MetadataTaxonomy } from '@/schemas/metadataTaxonomy';
+import { CreateMetadataTaxonomyRequestBody } from '@/managers/metadataTaxonomies';
+import { MetadataTaxonomies } from '@/schemas/metadataTaxonomies';
+import { UpdateMetadataTaxonomyRequestBody } from '@/managers/metadataTaxonomies';
+import { MetadataTaxonomyLevels } from '@/schemas/metadataTaxonomyLevels';
+import { MetadataTaxonomyLevel } from '@/schemas/metadataTaxonomyLevel';
+import { UpdateMetadataTaxonomyLevelByIdRequestBody } from '@/managers/metadataTaxonomies';
+import { AddMetadataTaxonomyLevelRequestBody } from '@/managers/metadataTaxonomies';
+import { MetadataTaxonomyNode } from '@/schemas/metadataTaxonomyNode';
+import { CreateMetadataTaxonomyNodeRequestBody } from '@/managers/metadataTaxonomies';
+import { MetadataTaxonomyNodes } from '@/schemas/metadataTaxonomyNodes';
+import { UpdateMetadataTaxonomyNodeRequestBody } from '@/managers/metadataTaxonomies';
+import { MetadataTemplate } from '@/schemas/metadataTemplate';
+import { CreateMetadataTemplateRequestBody } from '@/managers/metadataTemplates';
+import { CreateMetadataTemplateRequestBodyFieldsField } from '@/managers/metadataTemplates';
+import { CreateMetadataTemplateRequestBodyFieldsTypeField } from '@/managers/metadataTemplates';
+import { CreateMetadataTemplateRequestBodyFieldsOptionsRulesField } from '@/managers/metadataTemplates';
+import { DeleteMetadataTemplateScope } from '@/managers/metadataTemplates';
+import { getUuid } from '@/internal/utils';
+import { getEnvVar } from '@/internal/utils';
+import { delayInSeconds } from '@/internal/utils';
+import { getDefaultClient } from './commons';
+import { toString } from '@/internal/utils';
+import { sdToJson } from '@/serialization/json';
+import { SerializedData } from '@/serialization/json';
+import { sdIsEmpty } from '@/serialization/json';
+import { sdIsBoolean } from '@/serialization/json';
+import { sdIsNumber } from '@/serialization/json';
+import { sdIsString } from '@/serialization/json';
+import { sdIsList } from '@/serialization/json';
+import { sdIsMap } from '@/serialization/json';
+export const client: BoxClient = getDefaultClient();
+test('testMetadataTaxonomiesCRUD', async function testMetadataTaxonomiesCRUD(): Promise<any> {
+  const namespace: string = ''.concat(
+    'enterprise_',
+    getEnvVar('ENTERPRISE_ID'),
+  ) as string;
+  const uuid: string = getUuid();
+  const taxonomyKey: string = ''.concat('geography', uuid) as string;
+  const displayName: string = ''.concat('Geography Taxonomy', uuid) as string;
+  const createdTaxonomy: MetadataTaxonomy =
+    await client.metadataTaxonomies.createMetadataTaxonomy({
+      displayName: displayName,
+      key: taxonomyKey,
+      namespace: namespace,
+    } satisfies CreateMetadataTaxonomyRequestBody);
+  if (!(createdTaxonomy.displayName == displayName)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(createdTaxonomy.namespace == namespace)) {
+    throw new Error('Assertion failed');
+  }
+  const taxonomies: MetadataTaxonomies =
+    await client.metadataTaxonomies.getMetadataTaxonomies(namespace);
+  if (!(taxonomies.entries!.length > 0)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(taxonomies.entries![0].namespace == namespace)) {
+    throw new Error('Assertion failed');
+  }
+  const updatedDisplayName: string = ''.concat(
+    'Geography Taxonomy UPDATED',
+    uuid,
+  ) as string;
+  const updatedTaxonomy: MetadataTaxonomy =
+    await client.metadataTaxonomies.updateMetadataTaxonomy(
+      namespace,
+      taxonomyKey,
+      {
+        displayName: updatedDisplayName,
+      } satisfies UpdateMetadataTaxonomyRequestBody,
+    );
+  if (!(updatedTaxonomy.displayName == updatedDisplayName)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(updatedTaxonomy.namespace == namespace)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(updatedTaxonomy.id == createdTaxonomy.id)) {
+    throw new Error('Assertion failed');
+  }
+  const getTaxonomy: MetadataTaxonomy =
+    await client.metadataTaxonomies.getMetadataTaxonomyByKey(
+      namespace,
+      taxonomyKey,
+    );
+  if (!(getTaxonomy.displayName == updatedDisplayName)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(getTaxonomy.namespace == namespace)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(getTaxonomy.id == createdTaxonomy.id)) {
+    throw new Error('Assertion failed');
+  }
+  await client.metadataTaxonomies.deleteMetadataTaxonomy(
+    namespace,
+    taxonomyKey,
+  );
+  await expect(async () => {
+    await client.metadataTaxonomies.getMetadataTaxonomyByKey(
+      namespace,
+      taxonomyKey,
+    );
+  }).rejects.toThrow();
+});
+test('testMetadataTaxonomiesNodes', async function testMetadataTaxonomiesNodes(): Promise<any> {
+  const namespace: string = ''.concat(
+    'enterprise_',
+    getEnvVar('ENTERPRISE_ID'),
+  ) as string;
+  const uuid: string = getUuid();
+  const taxonomyKey: string = ''.concat('geography', uuid) as string;
+  const displayName: string = ''.concat('Geography Taxonomy', uuid) as string;
+  const createdTaxonomy: MetadataTaxonomy =
+    await client.metadataTaxonomies.createMetadataTaxonomy({
+      displayName: displayName,
+      key: taxonomyKey,
+      namespace: namespace,
+    } satisfies CreateMetadataTaxonomyRequestBody);
+  if (!(createdTaxonomy.displayName == displayName)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(createdTaxonomy.namespace == namespace)) {
+    throw new Error('Assertion failed');
+  }
+  const taxonomyLevels: MetadataTaxonomyLevels =
+    await client.metadataTaxonomies.createMetadataTaxonomyLevel(
+      namespace,
+      taxonomyKey,
+      [
+        {
+          displayName: 'Continent',
+          description: 'Continent Level',
+        } satisfies MetadataTaxonomyLevel,
+        {
+          displayName: 'Country',
+          description: 'Country Level',
+        } satisfies MetadataTaxonomyLevel,
+      ],
+    );
+  if (!(taxonomyLevels.entries!.length == 2)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(taxonomyLevels.entries![0].displayName == 'Continent')) {
+    throw new Error('Assertion failed');
+  }
+  if (!(taxonomyLevels.entries![1].displayName == 'Country')) {
+    throw new Error('Assertion failed');
+  }
+  const updatedTaxonomyLevels: MetadataTaxonomyLevel =
+    await client.metadataTaxonomies.updateMetadataTaxonomyLevelById(
+      namespace,
+      taxonomyKey,
+      1,
+      {
+        displayName: 'Continent UPDATED',
+        description: 'Continent Level UPDATED',
+      } satisfies UpdateMetadataTaxonomyLevelByIdRequestBody,
+    );
+  if (!(updatedTaxonomyLevels.displayName == 'Continent UPDATED')) {
+    throw new Error('Assertion failed');
+  }
+  if (!(updatedTaxonomyLevels.description == 'Continent Level UPDATED')) {
+    throw new Error('Assertion failed');
+  }
+  if (!(updatedTaxonomyLevels.level == taxonomyLevels.entries![0].level)) {
+    throw new Error('Assertion failed');
+  }
+  const taxonomyLevelsAfterAddition: MetadataTaxonomyLevels =
+    await client.metadataTaxonomies.addMetadataTaxonomyLevel(
+      namespace,
+      taxonomyKey,
+      {
+        displayName: 'Region',
+        description: 'Region Description',
+      } satisfies AddMetadataTaxonomyLevelRequestBody,
+    );
+  if (!(taxonomyLevelsAfterAddition.entries!.length == 3)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(taxonomyLevelsAfterAddition.entries![2].displayName == 'Region')) {
+    throw new Error('Assertion failed');
+  }
+  const taxonomyLevelsAfterDeletion: MetadataTaxonomyLevels =
+    await client.metadataTaxonomies.deleteMetadataTaxonomyLevel(
+      namespace,
+      taxonomyKey,
+    );
+  if (!(taxonomyLevelsAfterDeletion.entries!.length == 2)) {
+    throw new Error('Assertion failed');
+  }
+  if (
+    !(
+      taxonomyLevelsAfterDeletion.entries![0].displayName == 'Continent UPDATED'
+    )
+  ) {
+    throw new Error('Assertion failed');
+  }
+  if (!(taxonomyLevelsAfterDeletion.entries![1].displayName == 'Country')) {
+    throw new Error('Assertion failed');
+  }
+  const continentNode: MetadataTaxonomyNode =
+    await client.metadataTaxonomies.createMetadataTaxonomyNode(
+      namespace,
+      taxonomyKey,
+      {
+        displayName: 'Europe',
+        level: 1,
+      } satisfies CreateMetadataTaxonomyNodeRequestBody,
+    );
+  if (!(continentNode.displayName == 'Europe')) {
+    throw new Error('Assertion failed');
+  }
+  if (!(continentNode.level == 1)) {
+    throw new Error('Assertion failed');
+  }
+  const countryNode: MetadataTaxonomyNode =
+    await client.metadataTaxonomies.createMetadataTaxonomyNode(
+      namespace,
+      taxonomyKey,
+      {
+        displayName: 'Poland',
+        level: 2,
+        parentId: continentNode.id,
+      } satisfies CreateMetadataTaxonomyNodeRequestBody,
+    );
+  if (!(countryNode.displayName == 'Poland')) {
+    throw new Error('Assertion failed');
+  }
+  if (!(countryNode.level == 2)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(countryNode.parentId == continentNode.id)) {
+    throw new Error('Assertion failed');
+  }
+  await delayInSeconds(5);
+  const allNodes: MetadataTaxonomyNodes =
+    await client.metadataTaxonomies.getMetadataTaxonomyNodes(
+      namespace,
+      taxonomyKey,
+    );
+  if (!(allNodes.entries!.length == 2)) {
+    throw new Error('Assertion failed');
+  }
+  const updatedCountryNode: MetadataTaxonomyNode =
+    await client.metadataTaxonomies.updateMetadataTaxonomyNode(
+      namespace,
+      taxonomyKey,
+      countryNode.id,
+      {
+        requestBody: {
+          displayName: 'Poland UPDATED',
+        } satisfies UpdateMetadataTaxonomyNodeRequestBody,
+      } satisfies UpdateMetadataTaxonomyNodeOptionalsInput,
+    );
+  if (!(updatedCountryNode.displayName == 'Poland UPDATED')) {
+    throw new Error('Assertion failed');
+  }
+  if (!(updatedCountryNode.level == 2)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(updatedCountryNode.parentId == countryNode.parentId)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(updatedCountryNode.id == countryNode.id)) {
+    throw new Error('Assertion failed');
+  }
+  const getCountryNode: MetadataTaxonomyNode =
+    await client.metadataTaxonomies.getMetadataTaxonomyNodeById(
+      namespace,
+      taxonomyKey,
+      countryNode.id,
+    );
+  if (!(getCountryNode.displayName == 'Poland UPDATED')) {
+    throw new Error('Assertion failed');
+  }
+  if (!(getCountryNode.id == countryNode.id)) {
+    throw new Error('Assertion failed');
+  }
+  const metadataTemplateKey: string = ''.concat(
+    'templateKey',
+    getUuid(),
+  ) as string;
+  const metadataTemplate: MetadataTemplate =
+    await client.metadataTemplates.createMetadataTemplate({
+      scope: 'enterprise',
+      displayName: metadataTemplateKey,
+      templateKey: metadataTemplateKey,
+      fields: [
+        {
+          type: 'taxonomy' as CreateMetadataTemplateRequestBodyFieldsTypeField,
+          key: 'taxonomy',
+          displayName: 'taxonomy',
+          taxonomyKey: taxonomyKey,
+          namespace: namespace,
+          optionsRules: {
+            multiSelect: true,
+            selectableLevels: [1],
+          } satisfies CreateMetadataTemplateRequestBodyFieldsOptionsRulesField,
+        } satisfies CreateMetadataTemplateRequestBodyFieldsField,
+      ],
+    } satisfies CreateMetadataTemplateRequestBody);
+  if (!(metadataTemplate.templateKey == metadataTemplateKey)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(metadataTemplate.displayName == metadataTemplateKey)) {
+    throw new Error('Assertion failed');
+  }
+  if (!(metadataTemplate.fields!.length == 1)) {
+    throw new Error('Assertion failed');
+  }
+  if (!((toString(metadataTemplate.fields![0].type) as string) == 'taxonomy')) {
+    throw new Error('Assertion failed');
+  }
+  const options: MetadataTaxonomyNodes =
+    await client.metadataTaxonomies.getMetadataTemplateFieldOptions(
+      namespace,
+      metadataTemplateKey,
+      'taxonomy',
+    );
+  if (!(options.entries!.length == 1)) {
+    throw new Error('Assertion failed');
+  }
+  await client.metadataTemplates.deleteMetadataTemplate(
+    'enterprise' as DeleteMetadataTemplateScope,
+    metadataTemplateKey,
+  );
+  await client.metadataTaxonomies.deleteMetadataTaxonomyNode(
+    namespace,
+    taxonomyKey,
+    countryNode.id,
+  );
+  await client.metadataTaxonomies.deleteMetadataTaxonomyNode(
+    namespace,
+    taxonomyKey,
+    continentNode.id,
+  );
+  await delayInSeconds(5);
+  const allNodesAfterDeletion: MetadataTaxonomyNodes =
+    await client.metadataTaxonomies.getMetadataTaxonomyNodes(
+      namespace,
+      taxonomyKey,
+    );
+  if (!(allNodesAfterDeletion.entries!.length == 0)) {
+    throw new Error('Assertion failed');
+  }
+  await client.metadataTaxonomies.deleteMetadataTaxonomy(
+    namespace,
+    taxonomyKey,
+  );
+});
+export {};