dalux-build-api 1.1.5 → 2.0.1

package/src/models/files/index.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const { z } = require('zod');
+const { listResponseSchema, singleResponseSchema, nullableDefault } = require('../helpers');
+
+/** Mirrors models/files/models.py::Reference. */
+const ReferenceSchema = z.object({
+  key: z.string(),
+  value: z.string(),
+});
+
+/** Mirrors models/files/models.py::FileIntegerProperty. */
+const FileIntegerPropertySchema = z.object({
+  integer: z.number().nullish(),
+});
+
+/** Mirrors models/files/models.py::FileDateProperty. */
+const FileDatePropertySchema = z.object({
+  date: z.string().nullish(),
+});
+
+/** Mirrors models/files/models.py::FileTextProperty. */
+const FileTextPropertySchema = z.object({
+  text: z.string().nullish(),
+});
+
+/** Mirrors models/files/models.py::FileReferenceProperty. */
+const FileReferencePropertySchema = z.object({
+  reference: ReferenceSchema.nullish(),
+});
+
+/** Mirrors models/files/models.py::FilePropertyField. */
+const FilePropertyFieldSchema = z.object({
+  key: z.string(),
+  name: z.string(),
+  values: z.array(z.any()).nullish(),
+});
+
+/**
+ * Mirrors models/files/models.py::FileNameFilter. Client-side filter params
+ * (not part of any API response), so field names stay plain camelCase with
+ * no aliasing concerns on either side.
+ */
+const FileNameFilterSchema = z.object({
+  contains: z.array(z.string()).optional(),
+  containsMatch: z.enum(['any', 'all']).default('any'),
+  notContains: z.array(z.string()).optional(),
+  startswith: z.array(z.string()).optional(),
+  notStartswith: z.array(z.string()).optional(),
+  endswith: z.array(z.string()).optional(),
+  notEndswith: z.array(z.string()).optional(),
+  extensions: z.array(z.string()).optional(),
+  notExtensions: z.array(z.string()).optional(),
+});
+
+/**
+ * Mirrors models/files/models.py::File. `uploaded`/`lastModified` are kept
+ * as ISO date strings (not coerced to JS Date) so JSON round-tripping and
+ * existing string-based consumer code keeps working.
+ */
+const FileSchema = z.object({
+  fileId: z.string(),
+  fileRevisionId: z.string().nullish(),
+  fileName: z.string(),
+  fileAreaId: z.string(),
+  folderId: z.string().nullish(),
+  uploadedByUserId: z.string().nullish(),
+  uploaded: z.string().nullish(),
+  lastModifiedByUserId: z.string().nullish(),
+  lastModified: z.string().nullish(),
+  version: z.string().nullish(),
+  deleted: nullableDefault(z.boolean(), false),
+  fileType: z.string().nullish(),
+  fileSize: z.number().nullish(),
+  contentHash: z.string().nullish(),
+  downloadLink: z.string().nullish(),
+  properties: z.array(FilePropertyFieldSchema).nullish(),
+  // Local-only fields set by bulk-download helpers, not present in raw API responses.
+  savedFilePath: z.string().nullish(),
+  savedMetadataPath: z.string().nullish(),
+});
+
+const FilesListResponseSchema = listResponseSchema(FileSchema);
+const FileResponseSchema = singleResponseSchema(FileSchema);
+
+module.exports = {
+  ReferenceSchema,
+  FileIntegerPropertySchema,
+  FileDatePropertySchema,
+  FileTextPropertySchema,
+  FileReferencePropertySchema,
+  FilePropertyFieldSchema,
+  FileNameFilterSchema,
+  FileSchema,
+  FilesListResponseSchema,
+  FileResponseSchema,
+};

package/src/models/folders/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { z } = require('zod');
+const { listResponseSchema, singleResponseSchema } = require('../helpers');
+
+/** Mirrors models/folders/models.py::Folder. */
+const FolderSchema = z.object({
+  folderId: z.string(),
+  folderName: z.string(),
+  parentFolderId: z.string().nullish(),
+});
+
+const FoldersListResponseSchema = listResponseSchema(FolderSchema);
+const FolderResponseSchema = singleResponseSchema(FolderSchema);
+
+module.exports = {
+  FolderSchema,
+  FoldersListResponseSchema,
+  FolderResponseSchema,
+};

package/src/models/forms/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { z } = require('zod');
+const { listResponseSchema, singleResponseSchema } = require('../helpers');
+
+/**
+ * Mirrors models/forms/models.py::Form — empty placeholder in Python, so
+ * items stay untyped.
+ */
+const FormSchema = z.any();
+
+const FormsListResponseSchema = listResponseSchema(FormSchema);
+const FormResponseSchema = singleResponseSchema(FormSchema);
+
+module.exports = {
+  FormSchema,
+  FormsListResponseSchema,
+  FormResponseSchema,
+};

package/src/models/helpers.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const { z } = require('zod');
+const { LinkSchema, MetadataSchema } = require('./common');
+
+/**
+ * Unwraps a `{ data: {...} }` wrapper before validating against `schema`.
+ * Bare objects (no `data` wrapper) pass straight through.
+ * Mirrors the `unwrap_and_convert_items` field_validator repeated across
+ * every Python `responses.py` file.
+ * @param {import('zod').ZodTypeAny} schema
+ */
+function unwrapData(schema) {
+  return z.preprocess((value) => {
+    if (value && typeof value === 'object' && !Array.isArray(value) && 'data' in value) {
+      return value.data;
+    }
+    return value;
+  }, schema);
+}
+
+/**
+ * Builds a `{ items, metadata?, links? }` list-response schema.
+ * Accepts a bare array payload too (wraps it as `{ items: [...] }`) —
+ * mirrors TaskChanges' `wrap_list_payloads` model_validator.
+ * @param {import('zod').ZodTypeAny} itemSchema
+ */
+function listResponseSchema(itemSchema) {
+  return z.preprocess(
+    (value) => (Array.isArray(value) ? { items: value } : value),
+    z.object({
+      items: z.array(unwrapData(itemSchema)).default([]),
+      metadata: MetadataSchema.optional(),
+      links: z.array(LinkSchema).optional(),
+    }),
+  );
+}
+
+/**
+ * Builds a `{ data, links? }` single-item response schema.
+ * @param {import('zod').ZodTypeAny} itemSchema
+ */
+function singleResponseSchema(itemSchema) {
+  return z.object({
+    data: itemSchema,
+    links: z.array(LinkSchema).optional(),
+  });
+}
+
+/**
+ * A defaulted field that also accepts an explicit JSON `null` (treated the
+ * same as an absent field) — mirrors Pydantic's `Optional[T] = default`,
+ * which accepts both a missing key and an explicit `null`. Plain
+ * `schema.default(x)` alone only fires on `undefined`, not `null`.
+ * @param {import('zod').ZodTypeAny} schema
+ * @param {*} defaultValue
+ */
+function nullableDefault(schema, defaultValue) {
+  return z.preprocess((v) => (v === null ? undefined : v), schema.default(defaultValue));
+}
+
+module.exports = { unwrapData, listResponseSchema, singleResponseSchema, nullableDefault };

package/src/models/index.js

@@ -0,0 +1,178 @@
+'use strict';
+
+/**
+ * Zod schemas for Dalux Build API responses. Mirrors the public surface of
+ * python/dalux_build/models/__init__.py, with a `Schema` suffix on every
+ * export name (these are zod schema objects, not constructible classes).
+ */
+
+const { LinkSchema, MetadataSchema } = require('./common');
+
+const {
+  ProjectSchema,
+  ProjectModuleSchema,
+  ProjectMetadataSchema,
+  ProjectTemplateSchema,
+  ProjectCompanySchema,
+  ProjectsListResponseSchema,
+  ProjectResponseSchema,
+} = require('./projects');
+
+const { FileAreaSchema, FileAreasListResponseSchema, FileAreaResponseSchema } = require('./fileAreas');
+
+const { FolderSchema, FoldersListResponseSchema, FolderResponseSchema } = require('./folders');
+
+const {
+  FileSchema,
+  ReferenceSchema,
+  FileNameFilterSchema,
+  FileIntegerPropertySchema,
+  FileDatePropertySchema,
+  FileTextPropertySchema,
+  FileReferencePropertySchema,
+  FilePropertyFieldSchema,
+  FilesListResponseSchema,
+  FileResponseSchema,
+} = require('./files');
+
+const { VersionSetSchema, VersionSetsListResponseSchema, VersionSetResponseSchema } = require('./versionSets');
+
+const { UserSchema, ProjectUserSchema, UsersListResponseSchema, UserResponseSchema } = require('./users');
+
+const { CompaniesListResponseSchema, CompanyResponseSchema } = require('./companies');
+
+const { CompanyCatalogListResponseSchema, CompanyCatalogResponseSchema } = require('./companyCatalog');
+
+const {
+  InspectionPlanSchema,
+  InspectionPlanItemSchema,
+  InspectionPlanItemZoneSchema,
+  InspectionPlanRegistrationSchema,
+  InspectionPlansListResponseSchema,
+  InspectionPlanItemsListResponseSchema,
+  InspectionPlanItemZonesListResponseSchema,
+  InspectionPlanRegistrationsListResponseSchema,
+} = require('./inspectionPlans');
+
+const {
+  TestPlanSchema,
+  TestPlanItemSchema,
+  TestPlanItemZoneSchema,
+  TestPlanRegistrationSchema,
+  TestPlansListResponseSchema,
+  TestPlanItemsListResponseSchema,
+  TestPlanItemZonesListResponseSchema,
+  TestPlanRegistrationsListResponseSchema,
+} = require('./testPlans');
+
+const { FormSchema, FormsListResponseSchema, FormResponseSchema } = require('./forms');
+
+const {
+  TaskSchema,
+  TaskAttachmentSchema,
+  TaskChangeSchema,
+  TaskChangeActorSchema,
+  TaskChangeFieldsSchema,
+  TaskChangeLocationSchema,
+  TaskListParamsSchema,
+  TasksListResponseSchema,
+  TaskResponseSchema,
+  TaskChangeResponseSchema,
+  TaskChangesSchema,
+  TaskAttachmentsListResponseSchema,
+} = require('./tasks');
+
+const { FileRevisionSchema } = require('./fileRevisions');
+const { FileUploadSchema } = require('./fileUpload');
+const { WorkPackageSchema, WorkPackagesListResponseSchema } = require('./workPackages');
+
+module.exports = {
+  // Base
+  LinkSchema,
+  MetadataSchema,
+  // Projects
+  ProjectSchema,
+  ProjectModuleSchema,
+  ProjectMetadataSchema,
+  ProjectTemplateSchema,
+  ProjectCompanySchema,
+  ProjectsListResponseSchema,
+  ProjectResponseSchema,
+  // File Areas
+  FileAreaSchema,
+  FileAreasListResponseSchema,
+  FileAreaResponseSchema,
+  // Folders
+  FolderSchema,
+  FoldersListResponseSchema,
+  FolderResponseSchema,
+  // Files
+  FileSchema,
+  ReferenceSchema,
+  FileNameFilterSchema,
+  FileIntegerPropertySchema,
+  FileDatePropertySchema,
+  FileTextPropertySchema,
+  FileReferencePropertySchema,
+  FilePropertyFieldSchema,
+  FilesListResponseSchema,
+  FileResponseSchema,
+  // Version Sets
+  VersionSetSchema,
+  VersionSetsListResponseSchema,
+  VersionSetResponseSchema,
+  // Users
+  UserSchema,
+  ProjectUserSchema,
+  UsersListResponseSchema,
+  UserResponseSchema,
+  // Companies
+  CompaniesListResponseSchema,
+  CompanyResponseSchema,
+  // Company Catalog
+  CompanyCatalogListResponseSchema,
+  CompanyCatalogResponseSchema,
+  // Inspection Plans
+  InspectionPlanSchema,
+  InspectionPlanItemSchema,
+  InspectionPlanItemZoneSchema,
+  InspectionPlanRegistrationSchema,
+  InspectionPlansListResponseSchema,
+  InspectionPlanItemsListResponseSchema,
+  InspectionPlanItemZonesListResponseSchema,
+  InspectionPlanRegistrationsListResponseSchema,
+  // Test Plans
+  TestPlanSchema,
+  TestPlanItemSchema,
+  TestPlanItemZoneSchema,
+  TestPlanRegistrationSchema,
+  TestPlansListResponseSchema,
+  TestPlanItemsListResponseSchema,
+  TestPlanItemZonesListResponseSchema,
+  TestPlanRegistrationsListResponseSchema,
+  // Forms
+  FormSchema,
+  FormsListResponseSchema,
+  FormResponseSchema,
+  // Tasks
+  TaskSchema,
+  TaskAttachmentSchema,
+  TaskChangeSchema,
+  TaskChangeActorSchema,
+  TaskChangeFieldsSchema,
+  TaskChangeLocationSchema,
+  TaskListParamsSchema,
+  TasksListResponseSchema,
+  TaskResponseSchema,
+  TaskChangeResponseSchema,
+  TaskChangesSchema,
+  TaskAttachmentsListResponseSchema,
+  // Project Templates (same ProjectTemplateSchema as Projects, re-exported above)
+  // File Revisions
+  FileRevisionSchema,
+  // File Upload
+  FileUploadSchema,
+  // Work Packages
+  WorkPackageSchema,
+  WorkPackagesListResponseSchema,
+};

package/src/models/inspectionPlans/index.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const { z } = require('zod');
+const { listResponseSchema } = require('../helpers');
+
+const optionalString = z.string().nullish();
+const optionalInteger = z.number().int().nullish();
+
+const InspectionPlanSchema = z.object({
+  inspectionPlanId: optionalString,
+  name: optionalString,
+  workpackageId: optionalString,
+}).passthrough();
+
+const InspectionPlanItemSchema = z.object({
+  inspectionPlanItemId: optionalString,
+  inspectionPlanId: optionalString,
+  number: optionalString,
+  subject: optionalString,
+  heading: optionalString,
+  subHeading: optionalString,
+  extentType: optionalString,
+  planned: optionalInteger,
+  ongoing: optionalInteger,
+  completed: optionalInteger,
+  nonPlannedOngoing: optionalInteger,
+  nonPlannedCompleted: optionalInteger,
+}).passthrough();
+
+const InspectionPlanItemZoneSchema = z.object({
+  inspectionPlanItemId: optionalString,
+  inspectionPlanItemZoneId: optionalString,
+  name: optionalString,
+  planned: optionalInteger,
+  ongoing: optionalInteger,
+  completed: optionalInteger,
+}).passthrough();
+
+const InspectionPlanRegistrationSchema = z.object({
+  status: optionalString,
+  formId: optionalString,
+  taskId: optionalString,
+  inspectionPlanItemId: optionalString,
+  inspectionPlanItemZoneId: optionalString,
+}).passthrough();
+
+const InspectionPlansListResponseSchema = listResponseSchema(InspectionPlanSchema);
+const InspectionPlanItemsListResponseSchema = listResponseSchema(InspectionPlanItemSchema);
+const InspectionPlanItemZonesListResponseSchema = listResponseSchema(InspectionPlanItemZoneSchema);
+const InspectionPlanRegistrationsListResponseSchema = listResponseSchema(InspectionPlanRegistrationSchema);
+
+module.exports = {
+  InspectionPlanSchema,
+  InspectionPlanItemSchema,
+  InspectionPlanItemZoneSchema,
+  InspectionPlanRegistrationSchema,
+  InspectionPlansListResponseSchema,
+  InspectionPlanItemsListResponseSchema,
+  InspectionPlanItemZonesListResponseSchema,
+  InspectionPlanRegistrationsListResponseSchema,
+};

package/src/models/projectTemplates/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const { ProjectTemplateSchema } = require('../projects');
+
+/**
+ * Mirrors models/project_templates/models.py::ProjectTemplate — identical
+ * shape to projects/models.py::ProjectTemplate, so it's reused rather than
+ * duplicated. listProjectTemplates returns raw/unmodeled data in Python too
+ * (company-wide endpoint), so no response wrapper is defined here.
+ */
+module.exports = { ProjectTemplateSchema };

package/src/models/projects/index.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const { z } = require('zod');
+const { listResponseSchema, singleResponseSchema } = require('../helpers');
+
+/** Mirrors models/projects/models.py::ProjectModule (empty placeholder, passthrough). */
+const ProjectModuleSchema = z.object({}).passthrough();
+
+/** Mirrors models/projects/models.py::Project. Note: `type` is the real JSON key (Python aliases project_type -> "type"). */
+const ProjectSchema = z.object({
+  projectId: z.string(),
+  projectName: z.string(),
+  type: z.string().nullish(),
+  projectTemplateId: z.string().nullish(),
+  address: z.string().nullish(),
+  number: z.string().nullish(),
+  created: z.string().nullish(),
+  closing: z.string().nullish(),
+  modules: z.array(ProjectModuleSchema).nullish(),
+});
+
+/** Mirrors models/projects/models.py::ProjectMetadata. */
+const ProjectMetadataSchema = z.object({
+  key: z.string(),
+  value: z.string().nullish(),
+});
+
+/** Mirrors models/projects/models.py::ProjectTemplate (also duplicated in project_templates/models.py — same shape). */
+const ProjectTemplateSchema = z.object({
+  projectTemplateId: z.string(),
+  name: z.string(),
+});
+
+/** Mirrors models/projects/models.py::ProjectCompany. */
+const ProjectCompanySchema = z.object({
+  companyId: z.string().nullish(),
+  name: z.string().nullish(),
+  vatNumber: z.string().nullish(),
+  address: z.string().nullish(),
+  city: z.string().nullish(),
+  postalCode: z.string().nullish(),
+  country: z.string().nullish(),
+  catalogCompanyId: z.string().nullish(),
+});
+
+const ProjectsListResponseSchema = listResponseSchema(ProjectSchema);
+const ProjectResponseSchema = singleResponseSchema(ProjectSchema);
+
+module.exports = {
+  ProjectModuleSchema,
+  ProjectSchema,
+  ProjectMetadataSchema,
+  ProjectTemplateSchema,
+  ProjectCompanySchema,
+  ProjectsListResponseSchema,
+  ProjectResponseSchema,
+};

package/src/models/tasks/index.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const { z } = require('zod');
+const { listResponseSchema, singleResponseSchema } = require('../helpers');
+
+/** Mirrors models/tasks/models.py::Task (extra="allow" -> passthrough; only taskId is typed). */
+const TaskSchema = z.object({
+  taskId: z.string().nullish(),
+}).passthrough();
+
+/**
+ * Mirrors models/tasks/models.py::TaskListParams. Field names are the
+ * actual OData query keys (matches what src/api/TasksApi.js's
+ * normalizeTaskParams reads/writes) rather than Python's snake_case
+ * attribute names, since JS has no alias layer to bridge the two. These are
+ * developer-supplied query params (not API responses), so plain `.optional()`
+ * is fine.
+ */
+const TaskListParamsSchema = z.object({
+  typeId: z.string().optional(),
+  $filter: z.string().optional(),
+  $select: z.string().optional(),
+  $orderby: z.string().optional(),
+  $top: z.number().optional(),
+  $skip: z.number().optional(),
+  bookmark: z.string().optional(),
+}).passthrough();
+
+/** Mirrors models/tasks/models.py::TaskChangeActor. */
+const TaskChangeActorSchema = z.object({
+  userId: z.string().nullish(),
+  roleId: z.string().nullish(),
+  roleName: z.string().nullish(),
+  userName: z.string().nullish(),
+  name: z.string().nullish(),
+}).passthrough();
+
+/** Mirrors models/tasks/models.py::TaskChangeLocation (empty passthrough). */
+const TaskChangeLocationSchema = z.object({}).passthrough();
+
+/**
+ * Preprocesses the deadline field the same way Python's
+ * `normalize_deadline` field_validator does: unwraps API payloads where
+ * deadline is returned as an object instead of a bare string.
+ */
+const deadlineSchema = z.preprocess((value) => {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    if (value.empty === true) return undefined;
+    if ('value' in value) return value.value;
+    if ('date' in value) return value.date;
+    if ('datetime' in value) return value.datetime;
+  }
+  return value;
+}, z.string().nullish());
+
+/** Mirrors models/tasks/models.py::TaskChangeFields. */
+const TaskChangeFieldsSchema = z.object({
+  currentResponsible: TaskChangeActorSchema.nullish(),
+  assignedTo: TaskChangeActorSchema.nullish(),
+  title: z.string().nullish(),
+  deadline: deadlineSchema,
+  status: z.string().nullish(),
+  modifiedBy: TaskChangeActorSchema.nullish(),
+  userDefinedFields: z.record(z.any()).nullish(),
+  workpackageId: z.string().nullish(),
+  location: TaskChangeLocationSchema.nullish(),
+}).passthrough();
+
+/** Mirrors models/tasks/models.py::TaskChange. */
+const TaskChangeSchema = z.object({
+  taskId: z.string(),
+  description: z.string().nullish(),
+  timestamp: z.string(),
+  action: z.string(),
+  fields: TaskChangeFieldsSchema.nullish(),
+});
+
+/** Mirrors models/tasks/models.py::TaskAttachment. */
+const TaskAttachmentSchema = z.object({
+  attachmentId: z.string().nullish(),
+  taskId: z.string().nullish(),
+  fileId: z.string().nullish(),
+}).passthrough();
+
+const TasksListResponseSchema = listResponseSchema(TaskSchema);
+const TaskResponseSchema = singleResponseSchema(TaskSchema);
+const TaskChangeResponseSchema = singleResponseSchema(TaskChangeSchema);
+/** Bare-list payloads (`[...]` instead of `{items: [...]}`) are handled by listResponseSchema's preprocessor. */
+const TaskChangesSchema = listResponseSchema(TaskChangeSchema);
+const TaskAttachmentsListResponseSchema = listResponseSchema(TaskAttachmentSchema);
+
+module.exports = {
+  TaskSchema,
+  TaskListParamsSchema,
+  TaskChangeActorSchema,
+  TaskChangeLocationSchema,
+  TaskChangeFieldsSchema,
+  TaskChangeSchema,
+  TaskAttachmentSchema,
+  TasksListResponseSchema,
+  TaskResponseSchema,
+  TaskChangeResponseSchema,
+  TaskChangesSchema,
+  TaskAttachmentsListResponseSchema,
+};

package/src/models/testPlans/index.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const { z } = require('zod');
+const { listResponseSchema } = require('../helpers');
+
+const optionalString = z.string().nullish();
+const optionalInteger = z.number().int().nullish();
+
+const TestPlanSchema = z.object({
+  testPlanId: optionalString,
+  name: optionalString,
+  workpackageId: optionalString,
+}).passthrough();
+
+const TestPlanItemSchema = z.object({
+  testPlanItemId: optionalString,
+  testPlanId: optionalString,
+  number: optionalString,
+  subject: optionalString,
+  heading: optionalString,
+  subHeading: optionalString,
+  extentType: optionalString,
+  planned: optionalInteger,
+  ongoing: optionalInteger,
+  completed: optionalInteger,
+  nonPlannedOngoing: optionalInteger,
+  nonPlannedCompleted: optionalInteger,
+}).passthrough();
+
+const TestPlanItemZoneSchema = z.object({
+  testPlanItemId: optionalString,
+  testPlanItemZoneId: optionalString,
+  name: optionalString,
+  planned: optionalInteger,
+  ongoing: optionalInteger,
+  completed: optionalInteger,
+}).passthrough();
+
+const TestPlanRegistrationSchema = z.object({
+  status: optionalString,
+  formId: optionalString,
+  taskId: optionalString,
+  testPlanItemId: optionalString,
+  testPlanItemZoneId: optionalString,
+}).passthrough();
+
+const TestPlansListResponseSchema = listResponseSchema(TestPlanSchema);
+const TestPlanItemsListResponseSchema = listResponseSchema(TestPlanItemSchema);
+const TestPlanItemZonesListResponseSchema = listResponseSchema(TestPlanItemZoneSchema);
+const TestPlanRegistrationsListResponseSchema = listResponseSchema(TestPlanRegistrationSchema);
+
+module.exports = {
+  TestPlanSchema,
+  TestPlanItemSchema,
+  TestPlanItemZoneSchema,
+  TestPlanRegistrationSchema,
+  TestPlansListResponseSchema,
+  TestPlanItemsListResponseSchema,
+  TestPlanItemZonesListResponseSchema,
+  TestPlanRegistrationsListResponseSchema,
+};