repzo 1.0.291 → 1.0.293

package/src/index.ts

@@ -162,6 +162,38 @@ export const end_points = {
   BULK_EXPORT: "bulk-export",
   DELIVERY_NOTE: "delivery-note",
   RESERVATION: "reservation",
+  AI_OBJECT_DETECTION_DATASET: "ai-object-detection-dataset",
+  AI_OBJECT_DETECTION_MODEL: "ai-object-detection-model",
+  AI_OBJECT_DETECTION_MODEL_VERSION: "ai-object-detection-model-version",
+  AI_OBJECT_DETECTION_MODEL_VERSION_EPOCH:
+    "ai-object-detection-model-version-epoch",
+  AI_OBJECT_DETECTION_MODEL_VERSION_TRAIN_AGENT:
+    "ai-object-detection-model-version-train-agent",
+  AI_OBJECT_DETECTION_LABEL: "ai-object-detection-label",
+  AI_OBJECT_DETECTION_LABEL_GROUP: "ai-object-detection-label-group",
+  AI_OBJECT_DETECTION_CATEGORY: "ai-object-detection-category",
+  AI_OBJECT_DETECTION_SEGMENT: "ai-object-detection-segment",
+  AI_OBJECT_DETECTION_LABEL_REPORT: "ai-object-detection-label-report",
+  AI_OBJECT_DETECTION_SETTINGS: "ai-object-detection-settings",
+  AI_OBJECT_DETECTION_DETECTION_SETTINGS:
+    "ai-object-detection-detection-settings",
+  AI_OBJECT_DETECTION_INFERENCE: "ai-object-detection-inference",
+  AI_OBJECT_DETECTION_TASK: "ai-object-detection-task",
+  AI_OBJECT_DETECTION_SESSION: "ai-object-detection-session",
+  ACTIVITY_AI_OBJECT_DETECTION_SESSION_FRAME:
+    "activity-ai-object-detection-session-frame",
+  AI_OBJECT_DETECTION_SESSION_ANALYSIS: "ai-object-detection-session-analysis",
+  AI_OBJECT_DETECTION_SESSION_ELECTION: "ai-object-detection-session-election",
+  AI_OBJECT_DETECTION_SESSION_INSIGHT: "ai-object-detection-session-insight",
+  AI_OBJECT_DETECTION_METRIC: "ai-object-detection-metric",
+  AI_OBJECT_DETECTION_METRIC_RESULT: "ai-object-detection-metric-result",
+  AI_OBJECT_DETECTION_MISSION: "ai-object-detection-mission",
+  AI_OBJECT_DETECTION_MISSION_SET: "ai-object-detection-mission-set",
+  AI_OBJECT_DETECTION_MISSION_RESULTS: "ai-object-detection-mission-results",
+  AI_OBJECT_DETECTION_ASSIGNMENT_RULE: "ai-object-detection-assignment-rule",
+  AI_OBJECT_DETECTION_ASSIGNED_MISSIONS:
+    "ai-object-detection-assigned-missions",
+  OBJECT_DETECTION_ANALYTICS_REPORT: "object-detection-analytics-report",
 } as const;
 export type EndPoints = (typeof end_points)[keyof typeof end_points];
 
@@ -271,6 +303,33 @@ export const availableService = [
   "lineTarget",
   "bulkImport",
   "bulkExport",
+  "aiObjectDetectionDataset",
+  "aiObjectDetectionModel",
+  "aiObjectDetectionModelVersion",
+  "aiObjectDetectionModelVersionEpoch",
+  "aiObjectDetectionModelVersionTrainAgent",
+  "aiObjectDetectionLabel",
+  "aiObjectDetectionLabelGroup",
+  "aiObjectDetectionCategory",
+  "aiObjectDetectionSegment",
+  "aiObjectDetectionLabelReport",
+  "aiObjectDetectionSettings",
+  "aiObjectDetectionDetectionSettings",
+  "aiObjectDetectionInference",
+  "aiObjectDetectionTask",
+  "aiObjectDetectionSession",
+  "activityAiObjectDetectionSessionFrame",
+  "aiObjectDetectionSessionAnalysis",
+  "aiObjectDetectionSessionElection",
+  "aiObjectDetectionSessionInsight",
+  "aiObjectDetectionMetric",
+  "aiObjectDetectionMetricResult",
+  "aiObjectDetectionMission",
+  "aiObjectDetectionMissionSet",
+  "aiObjectDetectionMissionResults",
+  "aiObjectDetectionAssignmentRule",
+  "aiObjectDetectionAssignedMissions",
+  "objectDetectionAnalyticsReport",
 ] as const;
 export type AvailableService = (typeof availableService)[number];
 
@@ -423,6 +482,1217 @@ export default class Repzo {
     });
   }
 
+  aiObjectDetectionDataset = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_DATASET,
+    find: async (
+      params?: Service.AiObjectDetectionDataset.Find.Params,
+    ): Promise<Service.AiObjectDetectionDataset.Find.Result> => {
+      let res: Service.AiObjectDetectionDataset.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionDataset._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionDataset.Get.ID,
+      params?: Service.AiObjectDetectionDataset.Get.Params,
+    ): Promise<Service.AiObjectDetectionDataset.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionDataset._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionDataset.Create.Body,
+    ): Promise<Service.AiObjectDetectionDataset.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionDataset._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionDataset.Update.ID,
+      body: Service.AiObjectDetectionDataset.Update.Body,
+    ): Promise<Service.AiObjectDetectionDataset.Update.Result> => {
+      let res: Service.AiObjectDetectionDataset.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionDataset._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionDataset.Remove.ID,
+    ): Promise<Service.AiObjectDetectionDataset.Remove.Result> => {
+      let res: Service.AiObjectDetectionDataset.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionDataset._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionModel = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_MODEL,
+    find: async (
+      params?: Service.AiObjectDetectionModel.Find.Params,
+    ): Promise<Service.AiObjectDetectionModel.Find.Result> => {
+      let res: Service.AiObjectDetectionModel.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionModel._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionModel.Get.ID,
+      params?: Service.AiObjectDetectionModel.Get.Params,
+    ): Promise<Service.AiObjectDetectionModel.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionModel._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionModel.Create.Body,
+    ): Promise<Service.AiObjectDetectionModel.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionModel._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionModel.Update.ID,
+      body: Service.AiObjectDetectionModel.Update.Body,
+    ): Promise<Service.AiObjectDetectionModel.Update.Result> => {
+      let res: Service.AiObjectDetectionModel.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionModel._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionModel.Remove.ID,
+    ): Promise<Service.AiObjectDetectionModel.Remove.Result> => {
+      let res: Service.AiObjectDetectionModel.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionModel._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionModelVersion = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_MODEL_VERSION,
+    find: async (
+      params?: Service.AiObjectDetectionModelVersion.Find.Params,
+    ): Promise<Service.AiObjectDetectionModelVersion.Find.Result> => {
+      let res: Service.AiObjectDetectionModelVersion.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionModelVersion._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionModelVersion.Get.ID,
+      params?: Service.AiObjectDetectionModelVersion.Get.Params,
+    ): Promise<Service.AiObjectDetectionModelVersion.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionModelVersion._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionModelVersion.Create.Body,
+    ): Promise<Service.AiObjectDetectionModelVersion.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionModelVersion._path,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionModelVersion.Remove.ID,
+    ): Promise<Service.AiObjectDetectionModelVersion.Remove.Result> => {
+      let res: Service.AiObjectDetectionModelVersion.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionModelVersion._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionModelVersionEpoch = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_MODEL_VERSION_EPOCH,
+    find: async (
+      params: Service.AiObjectDetectionModelVersionEpoch.Find.Params,
+    ): Promise<Service.AiObjectDetectionModelVersionEpoch.Find.Result> => {
+      let res: Service.AiObjectDetectionModelVersionEpoch.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionModelVersionEpoch._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionModelVersionEpoch.Get.ID,
+    ): Promise<Service.AiObjectDetectionModelVersionEpoch.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionModelVersionEpoch._path + `/${id}`,
+      );
+    },
+  };
+
+  aiObjectDetectionModelVersionTrainAgent = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_MODEL_VERSION_TRAIN_AGENT,
+    get: async (
+      id: Service.AiObjectDetectionModelVersionTrainAgent.Get.ID,
+    ): Promise<Service.AiObjectDetectionModelVersionTrainAgent.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionModelVersionTrainAgent._path + `/${id}`,
+      );
+    },
+  };
+
+  aiObjectDetectionLabel = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_LABEL,
+    find: async (
+      params?: Service.AiObjectDetectionLabel.Find.Params,
+    ): Promise<Service.AiObjectDetectionLabel.Find.Result> => {
+      let res: Service.AiObjectDetectionLabel.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionLabel._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionLabel.Get.ID,
+      params?: Service.AiObjectDetectionLabel.Get.Params,
+    ): Promise<Service.AiObjectDetectionLabel.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionLabel._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionLabel.Create.Body,
+    ): Promise<Service.AiObjectDetectionLabel.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionLabel._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionLabel.Update.ID,
+      body: Service.AiObjectDetectionLabel.Update.Body,
+    ): Promise<Service.AiObjectDetectionLabel.Update.Result> => {
+      let res: Service.AiObjectDetectionLabel.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionLabel._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionLabel.Remove.ID,
+    ): Promise<Service.AiObjectDetectionLabel.Remove.Result> => {
+      let res: Service.AiObjectDetectionLabel.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionLabel._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionLabelGroup = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_LABEL_GROUP,
+    find: async (
+      params?: Service.AiObjectDetectionLabelGroup.Find.Params,
+    ): Promise<Service.AiObjectDetectionLabelGroup.Find.Result> => {
+      let res: Service.AiObjectDetectionLabelGroup.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionLabelGroup._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionLabelGroup.Get.ID,
+    ): Promise<Service.AiObjectDetectionLabelGroup.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionLabelGroup._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionLabelGroup.Create.Body,
+    ): Promise<Service.AiObjectDetectionLabelGroup.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionLabelGroup._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionLabelGroup.Update.ID,
+      body: Service.AiObjectDetectionLabelGroup.Update.Body,
+    ): Promise<Service.AiObjectDetectionLabelGroup.Update.Result> => {
+      let res: Service.AiObjectDetectionLabelGroup.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionLabelGroup._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionLabelGroup.Remove.ID,
+      params?: Service.AiObjectDetectionLabelGroup.Remove.Params,
+    ): Promise<Service.AiObjectDetectionLabelGroup.Remove.Result> => {
+      let res: Service.AiObjectDetectionLabelGroup.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionLabelGroup._path + `/${id}`,
+          params,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionCategory = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_CATEGORY,
+    find: async (
+      params?: Service.AiObjectDetectionCategory.Find.Params,
+    ): Promise<Service.AiObjectDetectionCategory.Find.Result> => {
+      let res: Service.AiObjectDetectionCategory.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionCategory._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionCategory.Get.ID,
+    ): Promise<Service.AiObjectDetectionCategory.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionCategory._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionCategory.Create.Body,
+    ): Promise<Service.AiObjectDetectionCategory.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionCategory._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionCategory.Update.ID,
+      body: Service.AiObjectDetectionCategory.Update.Body,
+    ): Promise<Service.AiObjectDetectionCategory.Update.Result> => {
+      let res: Service.AiObjectDetectionCategory.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionCategory._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionCategory.Remove.ID,
+      params?: Service.AiObjectDetectionCategory.Remove.Params,
+    ): Promise<Service.AiObjectDetectionCategory.Remove.Result> => {
+      let res: Service.AiObjectDetectionCategory.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionCategory._path + `/${id}`,
+          params,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionSegment = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_SEGMENT,
+    find: async (
+      params?: Service.AiObjectDetectionSegment.Find.Params,
+    ): Promise<Service.AiObjectDetectionSegment.Find.Result> => {
+      let res: Service.AiObjectDetectionSegment.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSegment._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionSegment.Get.ID,
+    ): Promise<Service.AiObjectDetectionSegment.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSegment._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionSegment.Create.Body,
+    ): Promise<Service.AiObjectDetectionSegment.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSegment._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionSegment.Update.ID,
+      body: Service.AiObjectDetectionSegment.Update.Body,
+    ): Promise<Service.AiObjectDetectionSegment.Update.Result> => {
+      let res: Service.AiObjectDetectionSegment.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSegment._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionSegment.Remove.ID,
+    ): Promise<Service.AiObjectDetectionSegment.Remove.Result> => {
+      let res: Service.AiObjectDetectionSegment.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSegment._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionLabelReport = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_LABEL_REPORT,
+    find: async (
+      params: Service.AiObjectDetectionLabelReport.Find.Params,
+    ): Promise<Service.AiObjectDetectionLabelReport.Find.Result> => {
+      let res: Service.AiObjectDetectionLabelReport.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionLabelReport._path,
+          params,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionSettings = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_SETTINGS,
+    find: async (): Promise<Service.AiObjectDetectionSettings.Find.Result> => {
+      let res: Service.AiObjectDetectionSettings.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSettings._path,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionSettings.Get.ID,
+    ): Promise<Service.AiObjectDetectionSettings.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSettings._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionSettings.Create.Body,
+    ): Promise<Service.AiObjectDetectionSettings.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSettings._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionSettings.Update.ID,
+      body: Service.AiObjectDetectionSettings.Update.Body,
+    ): Promise<Service.AiObjectDetectionSettings.Update.Result> => {
+      let res: Service.AiObjectDetectionSettings.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSettings._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    patch: async (
+      body: Service.AiObjectDetectionSettings.Patch.Body,
+    ): Promise<Service.AiObjectDetectionSettings.Patch.Result> => {
+      let res: Service.AiObjectDetectionSettings.Patch.Result =
+        await this._patch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSettings._path,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionSettings.Remove.ID,
+    ): Promise<Service.AiObjectDetectionSettings.Remove.Result> => {
+      let res: Service.AiObjectDetectionSettings.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSettings._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionDetectionSettings = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_DETECTION_SETTINGS,
+    find: async (): Promise<Service.AiObjectDetectionDetectionSettings.Find.Result> => {
+      let res: Service.AiObjectDetectionDetectionSettings.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionDetectionSettings._path,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionDetectionSettings.Get.ID,
+    ): Promise<Service.AiObjectDetectionDetectionSettings.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionDetectionSettings._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionDetectionSettings.Create.Body,
+    ): Promise<Service.AiObjectDetectionDetectionSettings.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionDetectionSettings._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionDetectionSettings.Update.ID,
+      body: Service.AiObjectDetectionDetectionSettings.Update.Body,
+    ): Promise<Service.AiObjectDetectionDetectionSettings.Update.Result> => {
+      let res: Service.AiObjectDetectionDetectionSettings.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionDetectionSettings._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    patch: async (
+      body: Service.AiObjectDetectionDetectionSettings.Patch.Body,
+    ): Promise<Service.AiObjectDetectionDetectionSettings.Patch.Result> => {
+      let res: Service.AiObjectDetectionDetectionSettings.Patch.Result =
+        await this._patch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionDetectionSettings._path,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionDetectionSettings.Remove.ID,
+    ): Promise<Service.AiObjectDetectionDetectionSettings.Remove.Result> => {
+      let res: Service.AiObjectDetectionDetectionSettings.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionDetectionSettings._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionInference = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_INFERENCE,
+    create: async (
+      body: Service.AiObjectDetectionInference.Create.Body,
+    ): Promise<Service.AiObjectDetectionInference.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionInference._path,
+        body,
+      );
+      return res;
+    },
+  };
+
+  aiObjectDetectionTask = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_TASK,
+    find: async (
+      params?: Service.AiObjectDetectionTask.Find.Params,
+    ): Promise<Service.AiObjectDetectionTask.Find.Result> => {
+      let res: Service.AiObjectDetectionTask.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionTask._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionTask.Get.ID,
+      params?: Service.AiObjectDetectionTask.Get.Params,
+    ): Promise<Service.AiObjectDetectionTask.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionTask._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionTask.Create.Body,
+    ): Promise<Service.AiObjectDetectionTask.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionTask._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionTask.Update.ID,
+      body: Service.AiObjectDetectionTask.Update.Body,
+    ): Promise<Service.AiObjectDetectionTask.Update.Result> => {
+      let res: Service.AiObjectDetectionTask.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionTask._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    patch: async (
+      params: Service.AiObjectDetectionTask.Patch.Params,
+      body: Service.AiObjectDetectionTask.Patch.Body,
+    ): Promise<Service.AiObjectDetectionTask.Patch.Result> => {
+      let res: Service.AiObjectDetectionTask.Patch.Result = await this._patch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionTask._path,
+        body,
+        params,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionTask.Remove.ID,
+    ): Promise<Service.AiObjectDetectionTask.Remove.Result> => {
+      let res: Service.AiObjectDetectionTask.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionTask._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  aiObjectDetectionSession = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_SESSION,
+    find: async (
+      params?: Service.AiObjectDetectionSession.Find.Params,
+    ): Promise<Service.AiObjectDetectionSession.Find.Result> => {
+      let res: Service.AiObjectDetectionSession.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSession._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionSession.Get.ID,
+      params?: Service.AiObjectDetectionSession.Get.Params,
+    ): Promise<Service.AiObjectDetectionSession.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSession._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionSession.Create.Body,
+    ): Promise<Service.AiObjectDetectionSession.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSession._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionSession.Update.ID,
+      body: Service.AiObjectDetectionSession.Update.Body,
+    ): Promise<Service.AiObjectDetectionSession.Update.Result> => {
+      let res: Service.AiObjectDetectionSession.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSession._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    patch: async (
+      params: Service.AiObjectDetectionSession.Patch.Params,
+      body: Service.AiObjectDetectionSession.Patch.Body,
+    ): Promise<Service.AiObjectDetectionSession.Patch.Result> => {
+      let res: Service.AiObjectDetectionSession.Patch.Result =
+        await this._patch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSession._path,
+          body,
+          params,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionSession.Remove.ID,
+      params?: Service.AiObjectDetectionSession.Remove.Params,
+    ): Promise<Service.AiObjectDetectionSession.Remove.Result> => {
+      let res: Service.AiObjectDetectionSession.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSession._path + `/${id}`,
+          params,
+        );
+      return res;
+    },
+  };
+
+  activityAiObjectDetectionSessionFrame = {
+    _path: Repzo._end_points.ACTIVITY_AI_OBJECT_DETECTION_SESSION_FRAME,
+    create: async (
+      body: Service.ActivityAiObjectDetectionSessionFrame.Create.Body,
+    ): Promise<Service.ActivityAiObjectDetectionSessionFrame.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.activityAiObjectDetectionSessionFrame._path,
+        body,
+      );
+      return res;
+    },
+  };
+
+  aiObjectDetectionSessionAnalysis = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_SESSION_ANALYSIS,
+    find: async (
+      params?: Service.AiObjectDetectionSessionAnalysis.Find.Params,
+    ): Promise<Service.AiObjectDetectionSessionAnalysis.Find.Result> => {
+      let res: Service.AiObjectDetectionSessionAnalysis.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSessionAnalysis._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionSessionAnalysis.Get.ID,
+      params?: Service.AiObjectDetectionSessionAnalysis.Get.Params,
+    ): Promise<Service.AiObjectDetectionSessionAnalysis.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSessionAnalysis._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionSessionAnalysis.Create.Body,
+    ): Promise<Service.AiObjectDetectionSessionAnalysis.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSessionAnalysis._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionSessionAnalysis.Update.ID,
+      body: Service.AiObjectDetectionSessionAnalysis.Update.Body,
+    ): Promise<Service.AiObjectDetectionSessionAnalysis.Update.Result> => {
+      let res: Service.AiObjectDetectionSessionAnalysis.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSessionAnalysis._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    patch: async (
+      params: Service.AiObjectDetectionSessionAnalysis.Patch.Params,
+      body: Service.AiObjectDetectionSessionAnalysis.Patch.Body,
+    ): Promise<Service.AiObjectDetectionSessionAnalysis.Patch.Result> => {
+      let res: Service.AiObjectDetectionSessionAnalysis.Patch.Result =
+        await this._patch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSessionAnalysis._path,
+          body,
+          params,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionSessionAnalysis.Remove.ID,
+    ): Promise<Service.AiObjectDetectionSessionAnalysis.Remove.Result> => {
+      let res: Service.AiObjectDetectionSessionAnalysis.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSessionAnalysis._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionSessionElection = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_SESSION_ELECTION,
+    create: async (
+      body: Service.AiObjectDetectionSessionElection.Create.Body,
+    ): Promise<Service.AiObjectDetectionSessionElection.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSessionElection._path,
+        body,
+      );
+      return res;
+    },
+  };
+
+  aiObjectDetectionSessionInsight = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_SESSION_INSIGHT,
+    find: async (
+      params?: Service.AiObjectDetectionSessionInsight.Find.Params,
+    ): Promise<Service.AiObjectDetectionSessionInsight.Find.Result> => {
+      let res: Service.AiObjectDetectionSessionInsight.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionSessionInsight._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionSessionInsight.Get.ID,
+    ): Promise<Service.AiObjectDetectionSessionInsight.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSessionInsight._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionSessionInsight.Create.Body,
+    ): Promise<Service.AiObjectDetectionSessionInsight.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionSessionInsight._path,
+        body,
+      );
+      return res;
+    },
+  };
+
+  aiObjectDetectionMetric = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_METRIC,
+    find: async (
+      params?: Service.AiObjectDetectionMetric.Find.Params,
+    ): Promise<Service.AiObjectDetectionMetric.Find.Result> => {
+      let res: Service.AiObjectDetectionMetric.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionMetric._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionMetric.Get.ID,
+    ): Promise<Service.AiObjectDetectionMetric.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionMetric._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionMetric.Create.Body,
+    ): Promise<Service.AiObjectDetectionMetric.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionMetric._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionMetric.Update.ID,
+      body: Service.AiObjectDetectionMetric.Update.Body,
+    ): Promise<Service.AiObjectDetectionMetric.Update.Result> => {
+      let res: Service.AiObjectDetectionMetric.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMetric._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionMetric.Remove.ID,
+    ): Promise<Service.AiObjectDetectionMetric.Remove.Result> => {
+      let res: Service.AiObjectDetectionMetric.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMetric._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionMetricResult = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_METRIC_RESULT,
+    find: async (
+      params?: Service.AiObjectDetectionMetricResult.Find.Params,
+    ): Promise<Service.AiObjectDetectionMetricResult.Find.Result> => {
+      let res: Service.AiObjectDetectionMetricResult.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMetricResult._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionMetricResult.Get.ID,
+    ): Promise<Service.AiObjectDetectionMetricResult.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionMetricResult._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionMetricResult.Create.Body,
+    ): Promise<Service.AiObjectDetectionMetricResult.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionMetricResult._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionMetricResult.Update.ID,
+      body: Service.AiObjectDetectionMetricResult.Update.Body,
+    ): Promise<Service.AiObjectDetectionMetricResult.Update.Result> => {
+      let res: Service.AiObjectDetectionMetricResult.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMetricResult._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionMetricResult.Remove.ID,
+    ): Promise<Service.AiObjectDetectionMetricResult.Remove.Result> => {
+      let res: Service.AiObjectDetectionMetricResult.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMetricResult._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionMission = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_MISSION,
+    find: async (
+      params?: Service.AiObjectDetectionMission.Find.Params,
+    ): Promise<Service.AiObjectDetectionMission.Find.Result> => {
+      let res: Service.AiObjectDetectionMission.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionMission._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionMission.Get.ID,
+    ): Promise<Service.AiObjectDetectionMission.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionMission._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionMission.Create.Body,
+    ): Promise<Service.AiObjectDetectionMission.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionMission._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionMission.Update.ID,
+      body: Service.AiObjectDetectionMission.Update.Body,
+    ): Promise<Service.AiObjectDetectionMission.Update.Result> => {
+      let res: Service.AiObjectDetectionMission.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMission._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionMission.Remove.ID,
+    ): Promise<Service.AiObjectDetectionMission.Remove.Result> => {
+      let res: Service.AiObjectDetectionMission.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMission._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionMissionSet = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_MISSION_SET,
+    find: async (
+      params?: Service.AiObjectDetectionMissionSet.Find.Params,
+    ): Promise<Service.AiObjectDetectionMissionSet.Find.Result> => {
+      let res: Service.AiObjectDetectionMissionSet.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMissionSet._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionMissionSet.Get.ID,
+    ): Promise<Service.AiObjectDetectionMissionSet.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionMissionSet._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionMissionSet.Create.Body,
+    ): Promise<Service.AiObjectDetectionMissionSet.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionMissionSet._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionMissionSet.Update.ID,
+      body: Service.AiObjectDetectionMissionSet.Update.Body,
+    ): Promise<Service.AiObjectDetectionMissionSet.Update.Result> => {
+      let res: Service.AiObjectDetectionMissionSet.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMissionSet._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionMissionSet.Remove.ID,
+    ): Promise<Service.AiObjectDetectionMissionSet.Remove.Result> => {
+      let res: Service.AiObjectDetectionMissionSet.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMissionSet._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionMissionResults = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_MISSION_RESULTS,
+    find: async (
+      params?: Service.AiObjectDetectionMissionResults.Find.Params,
+    ): Promise<Service.AiObjectDetectionMissionResults.Find.Result> => {
+      let res: Service.AiObjectDetectionMissionResults.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMissionResults._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionMissionResults.Get.ID,
+      params?: Service.AiObjectDetectionMissionResults.Get.Params,
+    ): Promise<Service.AiObjectDetectionMissionResults.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionMissionResults._path + `/${id}`,
+        params,
+      );
+    },
+    update: async (
+      id: Service.AiObjectDetectionMissionResults.Update.ID,
+      body: Service.AiObjectDetectionMissionResults.Update.Body,
+    ): Promise<Service.AiObjectDetectionMissionResults.Update.Result> => {
+      let res: Service.AiObjectDetectionMissionResults.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMissionResults._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionMissionResults.Remove.ID,
+    ): Promise<Service.AiObjectDetectionMissionResults.Remove.Result> => {
+      let res: Service.AiObjectDetectionMissionResults.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionMissionResults._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionAssignmentRule = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_ASSIGNMENT_RULE,
+    find: async (
+      params?: Service.AiObjectDetectionAssignmentRule.Find.Params,
+    ): Promise<Service.AiObjectDetectionAssignmentRule.Find.Result> => {
+      let res: Service.AiObjectDetectionAssignmentRule.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionAssignmentRule._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionAssignmentRule.Get.ID,
+    ): Promise<Service.AiObjectDetectionAssignmentRule.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionAssignmentRule._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AiObjectDetectionAssignmentRule.Create.Body,
+    ): Promise<Service.AiObjectDetectionAssignmentRule.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionAssignmentRule._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AiObjectDetectionAssignmentRule.Update.ID,
+      body: Service.AiObjectDetectionAssignmentRule.Update.Body,
+    ): Promise<Service.AiObjectDetectionAssignmentRule.Update.Result> => {
+      let res: Service.AiObjectDetectionAssignmentRule.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionAssignmentRule._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.AiObjectDetectionAssignmentRule.Remove.ID,
+    ): Promise<Service.AiObjectDetectionAssignmentRule.Remove.Result> => {
+      let res: Service.AiObjectDetectionAssignmentRule.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionAssignmentRule._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  aiObjectDetectionAssignedMissions = {
+    _path: Repzo._end_points.AI_OBJECT_DETECTION_ASSIGNED_MISSIONS,
+    find: async (
+      params: Service.AiObjectDetectionAssignedMissions.Find.Params,
+    ): Promise<Service.AiObjectDetectionAssignedMissions.Find.Result> => {
+      let res: Service.AiObjectDetectionAssignedMissions.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.aiObjectDetectionAssignedMissions._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.AiObjectDetectionAssignedMissions.Get.ID,
+      params?: Service.AiObjectDetectionAssignedMissions.Get.Params,
+    ): Promise<Service.AiObjectDetectionAssignedMissions.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.aiObjectDetectionAssignedMissions._path + `/${id}`,
+        params,
+      );
+    },
+  };
+
+  objectDetectionAnalyticsReport = {
+    _path: Repzo._end_points.OBJECT_DETECTION_ANALYTICS_REPORT,
+    find: async (
+      params?: Service.ObjectDetectionAnalyticsReport.Find.Params,
+    ): Promise<Service.ObjectDetectionAnalyticsReport.Find.Result> => {
+      let res: Service.ObjectDetectionAnalyticsReport.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.objectDetectionAnalyticsReport._path,
+          params,
+        );
+      return res;
+    },
+    create: async (
+      body: Service.ObjectDetectionAnalyticsReport.Create.Body,
+      params?: Service.ObjectDetectionAnalyticsReport.Create.Params,
+    ): Promise<Service.ObjectDetectionAnalyticsReport.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.objectDetectionAnalyticsReport._path,
+        body,
+        params,
+      );
+      return res;
+    },
+  };
+
   available_services = availableService;
 
   generateUUID = ({