repzo 1.0.155 → 1.0.156

package/src/index.ts

@@ -0,0 +1,4890 @@
+import axios from "axios";
+import { v4 as uuid } from "uuid";
+import type {
+  Params,
+  Data,
+  Service,
+  Options,
+  Headers,
+  StringId,
+  NameSpaces,
+} from "./types/index";
+
+export const end_points = {
+  CLIENT: "client",
+  PRODUCT: "product",
+  VARIANT: "variant",
+  CATEGORY: "product-category",
+  SUB_CATEGORY: "product-sub-category",
+  BRAND: "product-brand",
+  PRODUCT_GROUP: "product-group",
+  TAX: "tax",
+  MEASUREUNIT: "measureunits",
+  MEASUREUNIT_FAMILY: "measureunit-family",
+  MEDIA: "media",
+  PRICELIST: "pricelists",
+  PRICELIST_ITEM: "pricelistsitems",
+  TEAM: "teams",
+  RETURN_REASON: "return-reason",
+  REP: "rep",
+  REP_BALANCE_SUMMARY: "rep-balance-summary",
+  TAG: "tag",
+  WAREHOUSE: "warehouse",
+  ROUTE: "route",
+  PRODUCT_MODIFIERS_GROUP: "product-modifiers-group",
+  CHANNEL: "client-channel",
+  SPECIALITY: "speciality",
+  CLIENT_CONTACT: "client-contact",
+  PAYMENT_TERM: "paymentterms",
+  BANK: "banks",
+  BANK_LIST: "bankslists",
+  CUSTOM_STATUS: "custom-status",
+  CUSTOM_LIST: "custom-list",
+  CUSTOM_LIST_ITEM: "custom-list-item",
+  INVENTORY_ADJUSTMENT_REASON: "inventory-adjustment-reason",
+  WORKORDER: "workorder",
+  WORKORDER_REQUEST: "workorder-request",
+  SUPPLIER: "supplier",
+  QUICK_CONVERT_TO_PDF: "quick-convert-to-pdf",
+  VISIT: "visit",
+  INVOICE: "fullinvoices",
+  PROFORMA: "proforma",
+  PAYMENT: "payments",
+  REFUND: "refund",
+  SETTLEMENT: "settlement",
+  CHECK: "checks",
+  DAY: "day",
+  RECEIVING_MATERIAL: "receiving-material",
+  ADJUST_ACCOUNT: "adjust-account",
+  TRANSFER: "transfer",
+  MSL: "msl",
+  MSL_PRODUCT: "msl-products",
+  MEDIA_STORAGE: "media-storage",
+  STORECHECK_TEMPLATE: "storecheck-template",
+  ACTIVITY_STORECHECK: "activity-storecheck",
+  ADJUST_INVENTORY: "adjust-inventory",
+  INVENTORY: "inventory",
+  INTEGRATION_APP: "integration-app",
+  JOIN_ACTIONS_WEBHOOK: "svix-integration",
+  INTEGRATION_ACTION_LOG: "integration-action-log",
+  INTEGRATION_COMMAND_LOG: "integration-command-log",
+  PATCH_ACTION: "patch-action",
+  UPDATE_INTEGRATION_META: "update-integration-meta",
+  ASSET_PART_TYPE: "asset-part-type",
+  ASSET_PART: "asset-part",
+  ASSET_PART_UNIT: "asset-part-unit",
+  ASSET_PART_RECEIVAL: "asset-part-receival",
+  ASSET_PART_TRANSFER: "asset-part-transfer",
+  RETURN_ASSET_PART_UNIT: "return-asset-part-unit",
+  STORE_ASSET_PART_UNIT: "store-asset-part-unit",
+  OCR_INVOICE_JOB_TEMPLATE: "ocr-invoice-job-template",
+  OCR_INVOICE_JOB_GROUP: "ocr-invoice-job-group",
+  ACTIVITY_AI_SALES_ORDER: "activity-ai-sales-order",
+  OCR_INVOICE_JOB: "ocr-invoice-job",
+  OCR_INVOICE_JOB_PAGE: "ocr-invoice-job-page",
+  SETTINGS: "settings",
+  MAIL_UNSUBSCRIBE: "mail-unsubscribe",
+  APPROVAL_REQUEST: "approval-request",
+  SAFE_INVOICE_SERIAL_COUNTER: "safe-invoice-serial-counter",
+  CLIENT_LOCATION: "client-location",
+  ASSET_TYPE: "asset-type",
+  ASSET: "asset",
+  ASSET_UNIT: "asset-unit",
+  WORKORDER_PORTAL: "workorder-portal",
+  APPROVAL: "approvals",
+  ACTIVITY_FEEDBACK: "activity-feedback",
+  ACTIVITY_FEEDBACKV2: "activity-feedback-v2",
+  FEEDBACK_OPTION: "feedback-options",
+  WORKORDER_CATEGORY: "workorder-category",
+  CONTRACT: "contract",
+  CONTRACT_INSTALLMENT: "contract-installment",
+  WORKORDER_PORTAL_LINK: "workorder-portal-link",
+  CUSTOM_FIELD: "customfields",
+  TIMELINE_REPORT: "timeline-report",
+  RESET_COMPANY_NAMESPACE: "reset-company-namespace",
+  TEST_RESET_COMPANY_NAMESPACE: "test-reset-company-namespace",
+} as const;
+export type EndPoints = (typeof end_points)[keyof typeof end_points];
+
+const availableService = [
+  "client",
+  "product",
+  "variant",
+  "category",
+  "sub_category",
+  "brand",
+  "product_group",
+  "tax",
+  "measureunit",
+  "measureunitFamily",
+  "media",
+  "priceList",
+  "priceListItem",
+  "team",
+  "returnReason",
+  "rep",
+  "tag",
+  "warehouse",
+  "route",
+  "productModifiersGroup",
+  "channel",
+  "speciality",
+  "clientContact",
+  "paymentTerm",
+  "bank",
+  "bank_list",
+  "customStatus",
+  "customList",
+  "customListItem",
+  "inventoryAdjustmentReason",
+  "workorder",
+  "workorderRequest",
+  "supplier",
+  "quickConvertToPdf",
+  "visit",
+  "activityFeedback",
+  "activityFeedbackV2",
+  "feedbackOption",
+  "invoice",
+  "proforma",
+  "payment",
+  "refund",
+  "settlement",
+  "check",
+  "day",
+  "receivingMaterial",
+  "adjustAccount",
+  "transfer",
+  "msl",
+  "mslProduct",
+  "mediaStorage",
+  "storecheckTemplate",
+  "activityStorecheck",
+  "adjustInventory",
+  "inventory",
+  "integrationApp",
+  "joinActionsWebHook",
+  "patchAction",
+  "updateIntegrationMeta",
+  "assetPartType",
+  "assetPart",
+  "assetPartUnit",
+  "assetPartReceival",
+  "assetPartTransfer",
+  "returnAssetPartUnit",
+  "storeAssetPartUnit",
+  "ocrInvoiceJobTemplate",
+  "ocrInvoiceJobGroup",
+  "activityAiSalesOrder",
+  "ocrInvoiceJob",
+  "ocrInvoiceJobPage",
+  "settings",
+  "mailUnsubscribe",
+  "approvalRequest",
+  "safeInvoiceSerialCounter",
+  "clientLocation",
+  "assetType",
+  "asset",
+  "assetUnit",
+  "workorderPortal",
+  "approval",
+  "workorderCategory",
+  "contract",
+  "contractInstallment",
+  "repBalanceSummary",
+  "workorderPortalLink",
+  "customField",
+] as const;
+export type AvailableService = (typeof availableService)[number];
+
+export default class Repzo {
+  private svAPIEndpoint: string;
+  headers: Headers;
+  private timeout: number;
+  constructor(apiKey: string, options?: Options) {
+    this.svAPIEndpoint =
+      !options?.env || options?.env == "production"
+        ? "https://sv.api.repzo.me"
+        : options?.env == "staging"
+          ? "https://staging.sv.api.repzo.me"
+          : options?.env == "local"
+            ? "http://localhost:3030"
+            : "";
+
+    this.headers = {
+      "api-key": apiKey,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    };
+    if (options?.headers) Object.assign(this.headers, options.headers);
+    if (options?.timeout) {
+      this.timeout = options.timeout;
+    } else {
+      this.timeout = 180000;
+    }
+  }
+
+  private static _end_points = end_points;
+  public static get END_POINTS() {
+    return Repzo._end_points;
+  }
+  private async _fetch(baseUrl: string, path: string, params?: Params) {
+    if (params) {
+      params = normalizeParams(params);
+    }
+    let res = await axios.get(`${baseUrl}/${path}`, {
+      params,
+      headers: this.headers,
+      timeout: this.timeout,
+    });
+    return res.data;
+  }
+
+  private async _create(
+    baseUrl: string,
+    path: string,
+    body: Data,
+    params?: Params,
+  ) {
+    let res = await axios.post(`${baseUrl}/${path}`, body, {
+      params,
+      headers: this.headers,
+      timeout: this.timeout,
+    });
+    return res.data;
+  }
+
+  private async _update(
+    baseUrl: string,
+    path: string,
+    body: Data,
+    params?: Params,
+  ) {
+    let res = await axios.put(`${baseUrl}/${path}`, body, {
+      params,
+      headers: this.headers,
+      timeout: this.timeout,
+    });
+    return res.data;
+  }
+
+  private async _patch(
+    baseUrl: string,
+    path: string,
+    body: Data,
+    params?: Params,
+  ) {
+    let res = await axios.put(`${baseUrl}/${path}`, body, {
+      params,
+      headers: this.headers,
+      timeout: this.timeout,
+    });
+    return res.data;
+  }
+
+  private async _delete(baseUrl: string, path: string, params?: Params) {
+    let res = await axios.delete(`${baseUrl}/${path}`, {
+      params,
+      headers: this.headers,
+      timeout: this.timeout,
+    });
+    return res.data;
+  }
+
+  available_services = availableService;
+
+  client = {
+    _path: Repzo._end_points.CLIENT,
+    find: async (
+      params?: Service.Client.Find.Params,
+    ): Promise<Service.Client.Find.Result> => {
+      let res: Service.Client.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.client._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Client.Get.ID,
+      params?: Service.Client.Get.Params,
+    ): Promise<Service.Client.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.client._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Client.Create.Body,
+    ): Promise<Service.Client.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.client._path, body);
+      return res;
+    },
+
+    update: async (
+      id: Service.Client.Update.ID,
+      body: Service.Client.Update.Body,
+    ): Promise<Service.Client.Update.Result> => {
+      let res: Service.Client.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.client._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Client.Remove.ID,
+    ): Promise<Service.Client.Remove.Result> => {
+      let res: Service.Client.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.client._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  product = {
+    _path: Repzo._end_points.PRODUCT,
+    find: async (
+      params?: Service.Product.Find.Params,
+    ): Promise<Service.Product.Find.Result> => {
+      let res: Service.Product.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.product._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Product.Get.ID,
+      params?: Service.Product.Get.Params,
+    ): Promise<Service.Product.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.product._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Product.Create.Body,
+    ): Promise<Service.Product.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.product._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.Product.Update.ID,
+      body: Service.Product.Update.Body,
+    ): Promise<Service.Product.Update.Result> => {
+      let res: Service.Product.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.product._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Product.Remove.ID,
+    ): Promise<Service.Product.Remove.Result> => {
+      let res: Service.Product.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.product._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  variant = {
+    _path: Repzo._end_points.VARIANT,
+    find: async (
+      params?: Service.Variant.Find.Params,
+    ): Promise<Service.Variant.Find.Result> => {
+      let res: Service.Variant.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.variant._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Variant.Get.ID,
+      params?: Service.Variant.Get.Params,
+    ): Promise<Service.Variant.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.variant._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Variant.Create.Body,
+    ): Promise<Service.Variant.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.variant._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.Variant.Update.ID,
+      body: Service.Variant.Update.Body,
+    ): Promise<Service.Variant.Update.Result> => {
+      let res: Service.Variant.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.variant._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Variant.Remove.ID,
+    ): Promise<Service.Variant.Remove.Result> => {
+      let res: Service.Variant.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.variant._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  category = {
+    _path: Repzo._end_points.CATEGORY,
+    find: async (
+      params?: Service.Category.Find.Params,
+    ): Promise<Service.Category.Find.Result> => {
+      let res: Service.Category.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.category._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Category.Get.ID,
+    ): Promise<Service.Category.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.category._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.Category.Create.Body,
+    ): Promise<Service.Category.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.category._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.Category.Update.ID,
+      body: Service.Category.Update.Body,
+    ): Promise<Service.Category.Update.Result> => {
+      let res: Service.Category.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.category._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Category.Remove.ID,
+    ): Promise<Service.Category.Remove.Result> => {
+      let res: Service.Category.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.category._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  sub_category = {
+    _path: Repzo._end_points.SUB_CATEGORY,
+    find: async (
+      params?: Service.SubCategory.Find.Params,
+    ): Promise<Service.SubCategory.Find.Result> => {
+      let res: Service.SubCategory.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.sub_category._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.SubCategory.Get.ID,
+      params?: Service.SubCategory.Get.Params,
+    ): Promise<Service.SubCategory.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.sub_category._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.SubCategory.Create.Body,
+    ): Promise<Service.SubCategory.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.sub_category._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.SubCategory.Update.ID,
+      body: Service.SubCategory.Update.Body,
+    ): Promise<Service.SubCategory.Update.Result> => {
+      let res: Service.SubCategory.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.sub_category._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.SubCategory.Remove.ID,
+    ): Promise<Service.SubCategory.Remove.Result> => {
+      let res: Service.SubCategory.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.sub_category._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  brand = {
+    _path: Repzo._end_points.BRAND,
+    find: async (
+      params?: Service.Brand.Find.Params,
+    ): Promise<Service.Brand.Find.Result> => {
+      let res: Service.Brand.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.brand._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Brand.Get.ID,
+    ): Promise<Service.Brand.Get.Result> => {
+      return await this._fetch(this.svAPIEndpoint, this.brand._path + `/${id}`);
+    },
+
+    create: async (
+      body: Service.Brand.Create.Body,
+    ): Promise<Service.Brand.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.brand._path, body);
+      return res;
+    },
+
+    update: async (
+      id: Service.Brand.Update.ID,
+      body: Service.Brand.Update.Body,
+    ): Promise<Service.Brand.Update.Result> => {
+      let res: Service.Brand.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.brand._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Brand.Remove.ID,
+    ): Promise<Service.Brand.Remove.Result> => {
+      let res: Service.Brand.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.brand._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  product_group = {
+    _path: Repzo._end_points.PRODUCT_GROUP,
+    find: async (
+      params?: Service.ProductGroup.Find.Params,
+    ): Promise<Service.ProductGroup.Find.Result> => {
+      let res: Service.ProductGroup.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.product_group._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.ProductGroup.Get.ID,
+    ): Promise<Service.ProductGroup.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.product_group._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.ProductGroup.Create.Body,
+    ): Promise<Service.ProductGroup.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.product_group._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.ProductGroup.Update.ID,
+      body: Service.ProductGroup.Update.Body,
+    ): Promise<Service.ProductGroup.Update.Result> => {
+      let res: Service.ProductGroup.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.product_group._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.ProductGroup.Remove.ID,
+    ): Promise<Service.ProductGroup.Remove.Result> => {
+      let res: Service.ProductGroup.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.product_group._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  tax = {
+    _path: Repzo._end_points.TAX,
+    find: async (
+      params?: Service.Tax.Find.Params,
+    ): Promise<Service.Tax.Find.Result> => {
+      let res: Service.Tax.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.tax._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (id: Service.Tax.Get.ID): Promise<Service.Tax.Get.Result> => {
+      return await this._fetch(this.svAPIEndpoint, this.tax._path + `/${id}`);
+    },
+
+    create: async (
+      body: Service.Tax.Create.Body,
+    ): Promise<Service.Tax.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.tax._path, body);
+      return res;
+    },
+
+    update: async (
+      id: Service.Tax.Update.ID,
+      body: Service.Tax.Update.Body,
+    ): Promise<Service.Tax.Update.Result> => {
+      let res: Service.Tax.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.tax._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Tax.Remove.ID,
+    ): Promise<Service.Tax.Remove.Result> => {
+      let res: Service.Tax.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.tax._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  measureunit = {
+    _path: Repzo._end_points.MEASUREUNIT,
+    find: async (
+      params?: Service.MeasureUnit.Find.Params,
+    ): Promise<Service.MeasureUnit.Find.Result> => {
+      let res: Service.MeasureUnit.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.measureunit._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.MeasureUnit.Get.ID,
+    ): Promise<Service.MeasureUnit.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.measureunit._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.MeasureUnit.Create.Body,
+    ): Promise<Service.MeasureUnit.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.measureunit._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.MeasureUnit.Update.ID,
+      body: Service.MeasureUnit.Update.Body,
+    ): Promise<Service.MeasureUnit.Update.Result> => {
+      let res: Service.MeasureUnit.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.measureunit._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.MeasureUnit.Remove.ID,
+    ): Promise<Service.MeasureUnit.Remove.Result> => {
+      let res: Service.MeasureUnit.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.measureunit._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  measureunitFamily = {
+    _path: Repzo._end_points.MEASUREUNIT_FAMILY,
+    find: async (
+      params?: Service.MeasureUnitFamily.Find.Params,
+    ): Promise<Service.MeasureUnitFamily.Find.Result> => {
+      let res: Service.MeasureUnitFamily.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.measureunitFamily._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.MeasureUnitFamily.Get.ID,
+    ): Promise<Service.MeasureUnitFamily.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.measureunitFamily._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.MeasureUnitFamily.Create.Body,
+    ): Promise<Service.MeasureUnitFamily.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.measureunitFamily._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.MeasureUnitFamily.Update.ID,
+      body: Service.MeasureUnitFamily.Update.Body,
+    ): Promise<Service.MeasureUnitFamily.Update.Result> => {
+      let res: Service.MeasureUnitFamily.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.measureunitFamily._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.MeasureUnitFamily.Remove.ID,
+    ): Promise<Service.MeasureUnitFamily.Remove.Result> => {
+      let res: Service.MeasureUnitFamily.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.measureunitFamily._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  media = {
+    _path: Repzo._end_points.MEDIA,
+    find: async (
+      params?: Service.Media.Find.Params,
+    ): Promise<Service.Media.Find.Result> => {
+      let res: Service.Media.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.media._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Media.Get.ID,
+    ): Promise<Service.Media.Get.Result> => {
+      return await this._fetch(this.svAPIEndpoint, this.media._path + `/${id}`);
+    },
+
+    create: async (
+      body: Service.Media.Create.Body,
+    ): Promise<Service.Media.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.media._path, body);
+      return res;
+    },
+
+    update: async (
+      id: Service.Media.Update.ID,
+      body: Service.Media.Update.Body,
+    ): Promise<Service.Media.Update.Result> => {
+      let res: Service.Media.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.media._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Media.Remove.ID,
+    ): Promise<Service.Media.Remove.Result> => {
+      let res: Service.Media.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.media._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  priceList = {
+    _path: Repzo._end_points.PRICELIST,
+    find: async (
+      params?: Service.PriceList.Find.Params,
+    ): Promise<Service.PriceList.Find.Result> => {
+      let res: Service.PriceList.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.priceList._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.PriceList.Get.ID,
+    ): Promise<Service.PriceList.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.priceList._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.PriceList.Create.Body,
+    ): Promise<Service.PriceList.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.priceList._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.PriceList.Update.ID,
+      body: Service.PriceList.Update.Body,
+    ): Promise<Service.PriceList.Update.Result> => {
+      let res: Service.PriceList.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.priceList._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.PriceList.Remove.ID,
+    ): Promise<Service.PriceList.Remove.Result> => {
+      let res: Service.PriceList.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.priceList._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  priceListItem = {
+    _path: Repzo._end_points.PRICELIST_ITEM,
+    find: async (
+      params?: Service.PriceListItem.Find.Params,
+    ): Promise<Service.PriceListItem.Find.Result> => {
+      let res: Service.PriceListItem.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.priceListItem._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.PriceListItem.Get.ID,
+    ): Promise<Service.PriceListItem.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.priceListItem._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.PriceListItem.Create.Body,
+    ): Promise<Service.PriceListItem.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.priceListItem._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.PriceListItem.Update.ID,
+      body: Service.PriceListItem.Update.Body,
+    ): Promise<Service.PriceListItem.Update.Result> => {
+      let res: Service.PriceListItem.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.priceListItem._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.PriceListItem.Remove.ID,
+    ): Promise<Service.PriceListItem.Remove.Result> => {
+      let res: Service.PriceListItem.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.priceListItem._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  team = {
+    _path: Repzo._end_points.TEAM,
+    find: async (
+      params?: Service.Team.Find.Params,
+    ): Promise<Service.Team.Find.Result> => {
+      let res: Service.Team.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.team._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (id: Service.Team.Get.ID): Promise<Service.Team.Get.Result> => {
+      return await this._fetch(this.svAPIEndpoint, this.team._path + `/${id}`);
+    },
+
+    create: async (
+      body: Service.Team.Create.Body,
+    ): Promise<Service.Team.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.team._path, body);
+      return res;
+    },
+
+    update: async (
+      id: Service.Team.Update.ID,
+      body: Service.Team.Update.Body,
+    ): Promise<Service.Team.Update.Result> => {
+      let res: Service.Team.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.team._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Team.Remove.ID,
+    ): Promise<Service.Team.Remove.Result> => {
+      let res: Service.Team.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.team._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  returnReason = {
+    _path: Repzo._end_points.RETURN_REASON,
+    find: async (
+      params?: Service.ReturnReason.Find.Params,
+    ): Promise<Service.ReturnReason.Find.Result> => {
+      let res: Service.ReturnReason.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.returnReason._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.ReturnReason.Get.ID,
+    ): Promise<Service.ReturnReason.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.returnReason._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.ReturnReason.Create.Body,
+    ): Promise<Service.ReturnReason.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.returnReason._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.ReturnReason.Update.ID,
+      body: Service.ReturnReason.Update.Body,
+    ): Promise<Service.ReturnReason.Update.Result> => {
+      let res: Service.ReturnReason.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.returnReason._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.ReturnReason.Remove.ID,
+    ): Promise<Service.ReturnReason.Remove.Result> => {
+      let res: Service.ReturnReason.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.returnReason._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  rep = {
+    _path: Repzo._end_points.REP,
+    find: async (
+      params?: Service.Rep.Find.Params,
+    ): Promise<Service.Rep.Find.Result> => {
+      let res: Service.Rep.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.rep._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Rep.Get.ID,
+      params?: Service.Rep.Get.Params,
+    ): Promise<Service.Rep.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.rep._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Rep.Create.Body,
+    ): Promise<Service.Rep.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.rep._path, body);
+      return res;
+    },
+
+    update: async (
+      id: Service.Rep.Update.ID,
+      body: Service.Rep.Update.Body,
+    ): Promise<Service.Rep.Update.Result> => {
+      let res: Service.Rep.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.rep._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Rep.Remove.ID,
+    ): Promise<Service.Rep.Remove.Result> => {
+      let res: Service.Rep.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.rep._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  tag = {
+    _path: Repzo._end_points.TAG,
+    find: async (
+      params?: Service.Tag.Find.Params,
+    ): Promise<Service.Tag.Find.Result> => {
+      let res: Service.Tag.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.tag._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (id: Service.Tag.Get.ID): Promise<Service.Tag.Get.Result> => {
+      return await this._fetch(this.svAPIEndpoint, this.tag._path + `/${id}`);
+    },
+
+    create: async (
+      body: Service.Tag.Create.Body,
+    ): Promise<Service.Tag.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.tag._path, body);
+      return res;
+    },
+
+    update: async (
+      id: Service.Tag.Update.ID,
+      body: Service.Tag.Update.Body,
+    ): Promise<Service.Tag.Update.Result> => {
+      let res: Service.Tag.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.tag._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Tag.Remove.ID,
+    ): Promise<Service.Tag.Remove.Result> => {
+      let res: Service.Tag.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.tag._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  warehouse = {
+    _path: Repzo._end_points.WAREHOUSE,
+    find: async (
+      params?: Service.Warehouse.Find.Params,
+    ): Promise<Service.Warehouse.Find.Result> => {
+      let res: Service.Warehouse.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.warehouse._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Warehouse.Get.ID,
+    ): Promise<Service.Warehouse.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.warehouse._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.Warehouse.Create.Body,
+    ): Promise<Service.Warehouse.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.warehouse._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.Warehouse.Update.ID,
+      body: Service.Warehouse.Update.Body,
+    ): Promise<Service.Warehouse.Update.Result> => {
+      let res: Service.Warehouse.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.warehouse._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Warehouse.Remove.ID,
+    ): Promise<Service.Warehouse.Remove.Result> => {
+      let res: Service.Warehouse.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.warehouse._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  route = {
+    _path: Repzo._end_points.ROUTE,
+    find: async (
+      params?: Service.Route.Find.Params,
+    ): Promise<Service.Route.Find.Result> => {
+      let res: Service.Route.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.route._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.Route.Get.ID,
+    ): Promise<Service.Route.Get.Result> => {
+      return await this._fetch(this.svAPIEndpoint, this.route._path + `/${id}`);
+    },
+    create: async (
+      body: Service.Route.Create.Body,
+    ): Promise<Service.Route.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.route._path, body);
+      return res;
+    },
+    update: async (
+      id: Service.Route.Update.ID,
+      body: Service.Route.Update.Body,
+    ): Promise<Service.Route.Update.Result> => {
+      let res: Service.Route.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.route._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.Route.Remove.ID,
+    ): Promise<Service.Route.Remove.Result> => {
+      let res: Service.Route.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.route._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  productModifiersGroup = {
+    _path: Repzo._end_points.PRODUCT_MODIFIERS_GROUP,
+    find: async (
+      params?: Service.ProductModifiersGroup.Find.Params,
+    ): Promise<Service.ProductModifiersGroup.Find.Result> => {
+      let res: Service.ProductModifiersGroup.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.productModifiersGroup._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.ProductModifiersGroup.Get.ID,
+    ): Promise<Service.ProductModifiersGroup.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.productModifiersGroup._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.ProductModifiersGroup.Create.Body,
+    ): Promise<Service.ProductModifiersGroup.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.productModifiersGroup._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.ProductModifiersGroup.Update.ID,
+      body: Service.ProductModifiersGroup.Update.Body,
+    ): Promise<Service.ProductModifiersGroup.Update.Result> => {
+      let res: Service.ProductModifiersGroup.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.productModifiersGroup._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.ProductModifiersGroup.Remove.ID,
+    ): Promise<Service.ProductModifiersGroup.Remove.Result> => {
+      let res: Service.ProductModifiersGroup.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.productModifiersGroup._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  channel = {
+    _path: Repzo._end_points.CHANNEL,
+    find: async (
+      params?: Service.Channel.Find.Params,
+    ): Promise<Service.Channel.Find.Result> => {
+      let res: Service.Channel.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.channel._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Channel.Get.ID,
+    ): Promise<Service.Channel.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.channel._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.Channel.Create.Body,
+    ): Promise<Service.Channel.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.channel._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.Channel.Update.ID,
+      body: Service.Channel.Update.Body,
+    ): Promise<Service.Channel.Update.Result> => {
+      let res: Service.Channel.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.channel._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Channel.Remove.ID,
+    ): Promise<Service.Channel.Remove.Result> => {
+      let res: Service.Channel.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.channel._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+  speciality = {
+    _path: Repzo._end_points.SPECIALITY,
+    find: async (
+      params?: Service.Speciality.Find.Params,
+    ): Promise<Service.Speciality.Find.Result> => {
+      let res: Service.Speciality.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.speciality._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Speciality.Get.ID,
+    ): Promise<Service.Speciality.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.speciality._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.Speciality.Create.Body,
+    ): Promise<Service.Speciality.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.speciality._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.Speciality.Update.ID,
+      body: Service.Speciality.Update.Body,
+    ): Promise<Service.Speciality.Update.Result> => {
+      let res: Service.Speciality.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.speciality._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Speciality.Remove.ID,
+    ): Promise<Service.Speciality.Remove.Result> => {
+      let res: Service.Speciality.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.speciality._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+  clientContact = {
+    _path: Repzo._end_points.CLIENT_CONTACT,
+    find: async (
+      params?: Service.ClientContact.Find.Params,
+    ): Promise<Service.ClientContact.Find.Result> => {
+      let res: Service.ClientContact.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.clientContact._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.ClientContact.Get.ID,
+    ): Promise<Service.ClientContact.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.clientContact._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.ClientContact.Create.Body,
+    ): Promise<Service.ClientContact.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.clientContact._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.ClientContact.Update.ID,
+      body: Service.ClientContact.Update.Body,
+    ): Promise<Service.ClientContact.Update.Result> => {
+      let res: Service.ClientContact.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.clientContact._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.ClientContact.Remove.ID,
+    ): Promise<Service.ClientContact.Remove.Result> => {
+      let res: Service.ClientContact.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.clientContact._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+  paymentTerm = {
+    _path: Repzo._end_points.PAYMENT_TERM,
+    find: async (
+      params?: Service.PaymentTerm.Find.Params,
+    ): Promise<Service.PaymentTerm.Find.Result> => {
+      let res: Service.PaymentTerm.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.paymentTerm._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.PaymentTerm.Get.ID,
+    ): Promise<Service.PaymentTerm.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.paymentTerm._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.PaymentTerm.Create.Body,
+    ): Promise<Service.PaymentTerm.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.paymentTerm._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.PaymentTerm.Update.ID,
+      body: Service.PaymentTerm.Update.Body,
+    ): Promise<Service.PaymentTerm.Update.Result> => {
+      let res: Service.PaymentTerm.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.paymentTerm._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.PaymentTerm.Remove.ID,
+    ): Promise<Service.PaymentTerm.Remove.Result> => {
+      let res: Service.PaymentTerm.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.paymentTerm._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  bank = {
+    _path: Repzo._end_points.BANK,
+    find: async (
+      params?: Service.Bank.Find.Params,
+    ): Promise<Service.Bank.Find.Result> => {
+      let res: Service.Bank.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.bank._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (id: Service.Bank.Get.ID): Promise<Service.Bank.Get.Result> => {
+      return await this._fetch(this.svAPIEndpoint, this.bank._path + `/${id}`);
+    },
+
+    create: async (
+      body: Service.Bank.Create.Body,
+    ): Promise<Service.Bank.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.bank._path, body);
+      return res;
+    },
+
+    update: async (
+      id: Service.Bank.Update.ID,
+      body: Service.Bank.Update.Body,
+    ): Promise<Service.Bank.Update.Result> => {
+      let res: Service.Bank.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.bank._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  bank_list = {
+    _path: Repzo._end_points.BANK_LIST,
+    find: async (
+      params?: Service.BankList.Find.Params,
+    ): Promise<Service.BankList.Find.Result> => {
+      let res: Service.BankList.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.bank_list._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.BankList.Get.ID,
+    ): Promise<Service.BankList.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.bank_list._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.BankList.Create.Body,
+    ): Promise<Service.BankList.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.bank_list._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.BankList.Update.ID,
+      body: Service.BankList.Update.Body,
+    ): Promise<Service.BankList.Update.Result> => {
+      let res: Service.BankList.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.bank_list._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  customStatus = {
+    _path: Repzo._end_points.CUSTOM_STATUS,
+    find: async (
+      params?: Service.CustomStatus.Find.Params,
+    ): Promise<Service.CustomStatus.Find.Result> => {
+      let res: Service.CustomStatus.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.customStatus._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.CustomStatus.Get.ID,
+    ): Promise<Service.CustomStatus.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.customStatus._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.CustomStatus.Create.Body,
+    ): Promise<Service.CustomStatus.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.customStatus._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.CustomStatus.Update.ID,
+      body: Service.CustomStatus.Update.Body,
+    ): Promise<Service.CustomStatus.Update.Result> => {
+      let res: Service.CustomStatus.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.customStatus._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.CustomStatus.Remove.ID,
+    ): Promise<Service.CustomStatus.Remove.Result> => {
+      let res: Service.CustomStatus.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.customStatus._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  customList = {
+    _path: Repzo._end_points.CUSTOM_LIST,
+    find: async (
+      params?: Service.CustomList.Find.Params,
+    ): Promise<Service.CustomList.Find.Result> => {
+      let res: Service.CustomList.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.customList._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.CustomList.Get.ID,
+      params?: Service.CustomList.Get.Params,
+    ): Promise<Service.CustomList.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.customList._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.CustomList.Create.Body,
+    ): Promise<Service.CustomList.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.customList._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.CustomList.Update.ID,
+      body: Service.CustomList.Update.Body,
+    ): Promise<Service.CustomList.Update.Result> => {
+      let res: Service.CustomList.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.customList._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.CustomList.Remove.ID,
+    ): Promise<Service.CustomList.Remove.Result> => {
+      let res: Service.CustomList.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.customList._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  customListItem = {
+    _path: Repzo._end_points.CUSTOM_LIST_ITEM,
+    find: async (
+      params?: Service.CustomListItem.Find.Params,
+    ): Promise<Service.CustomListItem.Find.Result> => {
+      let res: Service.CustomListItem.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.customListItem._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.CustomListItem.Get.ID,
+      params?: Service.CustomListItem.Get.Params,
+    ): Promise<Service.CustomListItem.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.customListItem._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.CustomListItem.Create.Body,
+    ): Promise<Service.CustomListItem.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.customListItem._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.CustomListItem.Update.ID,
+      body: Service.CustomListItem.Update.Body,
+    ): Promise<Service.CustomListItem.Update.Result> => {
+      let res: Service.CustomListItem.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.customListItem._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.CustomListItem.Remove.ID,
+    ): Promise<Service.CustomListItem.Remove.Result> => {
+      let res: Service.CustomListItem.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.customListItem._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  inventoryAdjustmentReason = {
+    _path: Repzo._end_points.INVENTORY_ADJUSTMENT_REASON,
+    find: async (
+      params?: Service.InventoryAdjustmentReason.Find.Params,
+    ): Promise<Service.InventoryAdjustmentReason.Find.Result> => {
+      let res: Service.InventoryAdjustmentReason.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.inventoryAdjustmentReason._path,
+          params,
+        );
+      return res;
+    },
+
+    get: async (
+      id: Service.InventoryAdjustmentReason.Get.ID,
+    ): Promise<Service.InventoryAdjustmentReason.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.inventoryAdjustmentReason._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      body: Service.InventoryAdjustmentReason.Create.Body,
+    ): Promise<Service.InventoryAdjustmentReason.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.inventoryAdjustmentReason._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.InventoryAdjustmentReason.Update.ID,
+      body: Service.InventoryAdjustmentReason.Update.Body,
+    ): Promise<Service.InventoryAdjustmentReason.Update.Result> => {
+      let res: Service.InventoryAdjustmentReason.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.customListItem._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+    remove: async (
+      id: Service.InventoryAdjustmentReason.Remove.ID,
+    ): Promise<Service.InventoryAdjustmentReason.Remove.Result> => {
+      let res: Service.InventoryAdjustmentReason.Remove.Result =
+        await this._delete(
+          this.svAPIEndpoint,
+          this.inventoryAdjustmentReason._path + `/${id}`,
+        );
+      return res;
+    },
+  };
+
+  workorder = {
+    _path: Repzo._end_points.WORKORDER,
+    find: async (
+      params?: Service.Workorder.Find.Params,
+    ): Promise<Service.Workorder.Find.Result> => {
+      let res: Service.Workorder.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.workorder._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.Workorder.Get.ID,
+      params?: Service.Workorder.Get.Params,
+    ): Promise<Service.Workorder.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.workorder._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.Workorder.Create.Body,
+    ): Promise<Service.Workorder.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.workorder._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.Workorder.Update.ID,
+      body: Service.Workorder.Update.Body,
+    ): Promise<Service.Workorder.Update.Result> => {
+      let res: Service.Workorder.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.workorder._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.Workorder.Remove.ID,
+    ): Promise<Service.Workorder.Remove.Result> => {
+      let res: Service.Workorder.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.workorder._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  workorderRequest = {
+    _path: Repzo._end_points.WORKORDER_REQUEST,
+    find: async (
+      params?: Service.WorkorderRequest.Find.Params,
+    ): Promise<Service.WorkorderRequest.Find.Result> => {
+      let res: Service.WorkorderRequest.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.workorderRequest._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.WorkorderRequest.Get.ID,
+      params?: Service.WorkorderRequest.Get.Params,
+    ): Promise<Service.WorkorderRequest.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.workorderRequest._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.WorkorderRequest.Create.Body,
+    ): Promise<Service.WorkorderRequest.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.workorderRequest._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.WorkorderRequest.Update.ID,
+      body: Service.WorkorderRequest.Update.Body,
+    ): Promise<Service.WorkorderRequest.Update.Result> => {
+      let res: Service.WorkorderRequest.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.workorderRequest._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.WorkorderRequest.Remove.ID,
+    ): Promise<Service.WorkorderRequest.Remove.Result> => {
+      let res: Service.WorkorderRequest.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.workorderRequest._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  supplier = {
+    _path: Repzo._end_points.SUPPLIER,
+    find: async (
+      params?: Service.Supplier.Find.Params,
+    ): Promise<Service.Supplier.Find.Result> => {
+      let res: Service.Supplier.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.supplier._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.Supplier.Get.ID,
+      params?: Service.Supplier.Get.Params,
+    ): Promise<Service.Supplier.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.supplier._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.Supplier.Create.Body,
+    ): Promise<Service.Supplier.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.supplier._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.Supplier.Update.ID,
+      body: Service.Supplier.Update.Body,
+    ): Promise<Service.Supplier.Update.Result> => {
+      let res: Service.Supplier.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.supplier._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  quickConvertToPdf = {
+    _path: Repzo._end_points.QUICK_CONVERT_TO_PDF,
+    find: async (
+      params?: Service.QuickConvertToPdf.Find.Params,
+    ): Promise<Service.QuickConvertToPdf.Find.Result> => {
+      let res: Service.QuickConvertToPdf.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.quickConvertToPdf._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.QuickConvertToPdf.Get.ID,
+      params?: Service.QuickConvertToPdf.Get.Params,
+    ): Promise<Service.QuickConvertToPdf.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.quickConvertToPdf._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.QuickConvertToPdf.Create.Body,
+    ): Promise<Service.QuickConvertToPdf.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.quickConvertToPdf._path,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.QuickConvertToPdf.Remove.ID,
+    ): Promise<Service.QuickConvertToPdf.Remove.Result> => {
+      let res: Service.QuickConvertToPdf.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.quickConvertToPdf._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+  visit = {
+    _path: Repzo._end_points.VISIT,
+    find: async (
+      params?: Service.Visit.Find.Params,
+    ): Promise<Service.Visit.Find.Result> => {
+      let res: Service.Visit.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.visit._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.Visit.Get.ID,
+      params?: Service.Visit.Get.Params,
+    ): Promise<Service.Visit.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.visit._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.Visit.Create.Body,
+    ): Promise<Service.Visit.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.visit._path, body);
+      return res;
+    },
+
+    update: async (
+      id: Service.Visit.Update.ID,
+      body: Service.Visit.Update.Body,
+    ): Promise<Service.Visit.Update.Result> => {
+      let res: Service.Visit.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.visit._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  activityFeedback = {
+    _path: Repzo._end_points.ACTIVITY_FEEDBACK,
+    find: async (
+      params?: Service.ActivityFeedback.Find.Params,
+    ): Promise<Service.ActivityFeedback.Find.Result> => {
+      let res: Service.ActivityFeedback.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.activityFeedback._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.ActivityFeedback.Get.ID,
+      params?: Service.ActivityFeedback.Get.Params,
+    ): Promise<Service.ActivityFeedback.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.activityFeedback._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.ActivityFeedback.Create.Body,
+    ): Promise<Service.ActivityFeedback.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.activityFeedback._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.ActivityFeedback.Update.ID,
+      body: Service.ActivityFeedback.Update.Body,
+    ): Promise<Service.ActivityFeedback.Update.Result> => {
+      let res: Service.ActivityFeedback.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.activityFeedback._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  activityFeedbackV2 = {
+    _path: Repzo._end_points.ACTIVITY_FEEDBACKV2,
+    find: async (
+      params?: Service.ActivityFeedbackV2.Find.Params,
+    ): Promise<Service.ActivityFeedbackV2.Find.Result> => {
+      let res: Service.ActivityFeedbackV2.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.activityFeedbackV2._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.ActivityFeedbackV2.Get.ID,
+      params?: Service.ActivityFeedbackV2.Get.Params,
+    ): Promise<Service.ActivityFeedbackV2.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.activityFeedbackV2._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.ActivityFeedbackV2.Create.Body,
+    ): Promise<Service.ActivityFeedbackV2.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.activityFeedbackV2._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.ActivityFeedbackV2.Update.ID,
+      body: Service.ActivityFeedbackV2.Update.Body,
+    ): Promise<Service.ActivityFeedbackV2.Update.Result> => {
+      let res: Service.ActivityFeedbackV2.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.activityFeedbackV2._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  feedbackOption = {
+    _path: Repzo._end_points.FEEDBACK_OPTION,
+    find: async (
+      params?: Service.FeedbackOption.Find.Params,
+    ): Promise<Service.FeedbackOption.Find.Result> => {
+      let res: Service.FeedbackOption.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.feedbackOption._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.FeedbackOption.Get.ID,
+      params?: Service.FeedbackOption.Get.Params,
+    ): Promise<Service.FeedbackOption.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.feedbackOption._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.FeedbackOption.Create.Body,
+    ): Promise<Service.FeedbackOption.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.feedbackOption._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.FeedbackOption.Update.ID,
+      body: Service.FeedbackOption.Update.Body,
+    ): Promise<Service.FeedbackOption.Update.Result> => {
+      let res: Service.FeedbackOption.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.feedbackOption._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  invoice = {
+    _path: Repzo._end_points.INVOICE,
+    find: async (
+      params?: Service.FullInvoice.Find.Params,
+    ): Promise<Service.FullInvoice.Find.Result> => {
+      let res: Service.FullInvoice.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.invoice._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.FullInvoice.Get.ID,
+      params?: Service.FullInvoice.Get.Params,
+    ): Promise<Service.FullInvoice.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.invoice._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.FullInvoice.Create.Body,
+    ): Promise<Service.FullInvoice.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.invoice._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.FullInvoice.Update.ID,
+      body: Service.FullInvoice.Update.Body,
+    ): Promise<Service.FullInvoice.Update.Result> => {
+      let res: Service.FullInvoice.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.invoice._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  proforma = {
+    _path: Repzo._end_points.PROFORMA,
+    find: async (
+      params?: Service.Proforma.Find.Params,
+    ): Promise<Service.Proforma.Find.Result> => {
+      let res: Service.Proforma.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.proforma._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Proforma.Get.ID,
+      params?: Service.Proforma.Get.Params,
+    ): Promise<Service.Proforma.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.proforma._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Proforma.Create.Body,
+    ): Promise<Service.Proforma.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.proforma._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.Proforma.Update.ID,
+      body: Service.Proforma.Update.Body,
+    ): Promise<Service.Proforma.Update.Result> => {
+      let res: Service.Proforma.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.proforma._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  payment = {
+    _path: Repzo._end_points.PAYMENT,
+    find: async (
+      params?: Service.Payment.Find.Params,
+    ): Promise<Service.Payment.Find.Result> => {
+      let res: Service.Payment.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.payment._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Payment.Get.ID,
+      params?: Service.Payment.Get.Params,
+    ): Promise<Service.Payment.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.payment._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Payment.Create.Body,
+    ): Promise<Service.Payment.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.payment._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.Payment.Update.ID,
+      body: Service.Payment.Update.Body,
+    ): Promise<Service.Payment.Update.Result> => {
+      let res: Service.Payment.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.payment._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  refund = {
+    _path: Repzo._end_points.REFUND,
+    find: async (
+      params?: Service.Refund.Find.Params,
+    ): Promise<Service.Refund.Find.Result> => {
+      let res: Service.Refund.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.refund._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Refund.Get.ID,
+      params?: Service.Refund.Get.Params,
+    ): Promise<Service.Refund.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.refund._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Refund.Create.Body,
+    ): Promise<Service.Refund.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.refund._path, body);
+      return res;
+    },
+
+    update: async (
+      id: Service.Refund.Update.ID,
+      body: Service.Refund.Update.Body,
+    ): Promise<Service.Refund.Update.Result> => {
+      let res: Service.Refund.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.refund._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  settlement = {
+    _path: Repzo._end_points.SETTLEMENT,
+
+    find: async (
+      params?: Service.Settlement.Find.Params,
+    ): Promise<Service.Settlement.Find.Result> => {
+      let res: Service.Settlement.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.settlement._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Settlement.Get.ID,
+      params?: Service.Settlement.Get.Params,
+    ): Promise<Service.Settlement.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.settlement._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Settlement.Create.Body,
+    ): Promise<Service.Settlement.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.settlement._path,
+        body,
+      );
+      return res;
+    },
+  };
+
+  check = {
+    _path: Repzo._end_points.CHECK,
+
+    find: async (
+      params?: Service.Check.Find.Params,
+    ): Promise<Service.Check.Find.Result> => {
+      let res: Service.Check.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.check._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Check.Get.ID,
+      params?: Service.Check.Get.Params,
+    ): Promise<Service.Check.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.check._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Check.Create.Body,
+    ): Promise<Service.Check.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.check._path, body);
+      return res;
+    },
+  };
+
+  day = {
+    _path: Repzo._end_points.DAY,
+
+    find: async (
+      params?: Service.Day.Find.Params,
+    ): Promise<Service.Day.Find.Result> => {
+      let res: Service.Day.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.day._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Day.Get.ID,
+      params?: Service.Day.Get.Params,
+    ): Promise<Service.Day.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.day._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Day.Create.Body,
+    ): Promise<Service.Day.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.day._path, body);
+      return res;
+    },
+  };
+
+  receivingMaterial = {
+    _path: Repzo._end_points.RECEIVING_MATERIAL,
+
+    find: async (
+      params?: Service.ReceivingMaterial.Find.Params,
+    ): Promise<Service.ReceivingMaterial.Find.Result> => {
+      let res: Service.ReceivingMaterial.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.receivingMaterial._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.ReceivingMaterial.Get.ID,
+      params?: Service.ReceivingMaterial.Get.Params,
+    ): Promise<Service.ReceivingMaterial.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.receivingMaterial._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.ReceivingMaterial.Create.Body,
+    ): Promise<Service.ReceivingMaterial.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.receivingMaterial._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.ReceivingMaterial.Update.ID,
+      body: Service.ReceivingMaterial.Update.Body,
+    ): Promise<Service.ReceivingMaterial.Update.Result> => {
+      let res: Service.ReceivingMaterial.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.receivingMaterial._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  adjustAccount = {
+    _path: Repzo._end_points.ADJUST_ACCOUNT,
+    find: async (
+      params?: Service.AdjustAccount.Find.Params,
+    ): Promise<Service.AdjustAccount.Find.Result> => {
+      let res: Service.AdjustAccount.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.adjustAccount._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.AdjustAccount.Get.ID,
+      params?: Service.AdjustAccount.Get.Params,
+    ): Promise<Service.AdjustAccount.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.adjustAccount._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.AdjustAccount.Create.Body,
+    ): Promise<Service.AdjustAccount.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.adjustAccount._path,
+        body,
+      );
+      return res;
+    },
+  };
+
+  transfer = {
+    _path: Repzo._end_points.TRANSFER,
+    find: async (
+      params?: Service.Transfer.Find.Params,
+    ): Promise<Service.Transfer.Find.Result> => {
+      let res: Service.Transfer.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.transfer._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Transfer.Get.ID,
+      params?: Service.Transfer.Get.Params,
+    ): Promise<Service.Transfer.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.transfer._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Transfer.Create.Body,
+    ): Promise<Service.Transfer.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.transfer._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.Transfer.Update.ID,
+      body: Service.Transfer.Update.Body,
+    ): Promise<Service.Transfer.Update.Result> => {
+      let res: Service.Transfer.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.transfer._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  msl = {
+    _path: Repzo._end_points.MSL,
+    find: async (
+      params?: Service.Msl.Find.Params,
+    ): Promise<Service.Msl.Find.Result> => {
+      let res: Service.Msl.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.msl._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.Msl.Get.ID,
+      params?: Service.Msl.Get.Params,
+    ): Promise<Service.Msl.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.msl._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.Msl.Create.Body,
+    ): Promise<Service.Msl.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.msl._path, body);
+      return res;
+    },
+
+    update: async (
+      id: Service.Msl.Update.ID,
+      body: Service.Msl.Update.Body,
+    ): Promise<Service.Msl.Update.Result> => {
+      let res: Service.Msl.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.msl._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.Msl.Remove.ID,
+    ): Promise<Service.Msl.Remove.Result> => {
+      let res: Service.Msl.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.msl._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  mslProduct = {
+    _path: Repzo._end_points.MSL_PRODUCT,
+    find: async (
+      params?: Service.MslProduct.Find.Params,
+    ): Promise<Service.MslProduct.Find.Result> => {
+      let res: Service.MslProduct.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.mslProduct._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.MslProduct.Get.ID,
+      params?: Service.MslProduct.Get.Params,
+    ): Promise<Service.MslProduct.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.mslProduct._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.MslProduct.Create.Body,
+    ): Promise<Service.MslProduct.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.mslProduct._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.MslProduct.Update.ID,
+      body: Service.MslProduct.Update.Body,
+    ): Promise<Service.MslProduct.Update.Result> => {
+      let res: Service.MslProduct.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.mslProduct._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.MslProduct.Remove.ID,
+    ): Promise<Service.MslProduct.Remove.Result> => {
+      let res: Service.MslProduct.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.mslProduct._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  mediaStorage = {
+    _path: Repzo._end_points.MEDIA_STORAGE,
+    find: async (
+      params?: Service.MediaStorage.Find.Params,
+    ): Promise<Service.MediaStorage.Find.Result> => {
+      let res: Service.MediaStorage.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.mediaStorage._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.MediaStorage.Get.ID,
+      params?: Service.MediaStorage.Get.Params,
+    ): Promise<Service.MediaStorage.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.mediaStorage._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.MediaStorage.Create.Body,
+    ): Promise<Service.MediaStorage.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.mediaStorage._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.MediaStorage.Update.ID,
+      body: Service.MediaStorage.Update.Body,
+    ): Promise<Service.MediaStorage.Update.Result> => {
+      let res: Service.MediaStorage.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.mediaStorage._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.MediaStorage.Remove.ID,
+    ): Promise<Service.MediaStorage.Remove.Result> => {
+      let res: Service.MediaStorage.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.mediaStorage._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  storecheckTemplate = {
+    _path: Repzo._end_points.STORECHECK_TEMPLATE,
+    find: async (
+      params?: Service.StorecheckTemplate.Find.Params,
+    ): Promise<Service.StorecheckTemplate.Find.Result> => {
+      let res: Service.StorecheckTemplate.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.storecheckTemplate._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.StorecheckTemplate.Get.ID,
+      params?: Service.StorecheckTemplate.Get.Params,
+    ): Promise<Service.StorecheckTemplate.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.storecheckTemplate._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.StorecheckTemplate.Create.Body,
+    ): Promise<Service.StorecheckTemplate.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.storecheckTemplate._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.StorecheckTemplate.Update.ID,
+      body: Service.StorecheckTemplate.Update.Body,
+    ): Promise<Service.StorecheckTemplate.Update.Result> => {
+      let res: Service.StorecheckTemplate.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.storecheckTemplate._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.StorecheckTemplate.Remove.ID,
+    ): Promise<Service.StorecheckTemplate.Remove.Result> => {
+      let res: Service.StorecheckTemplate.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.storecheckTemplate._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  activityStorecheck = {
+    _path: Repzo._end_points.ACTIVITY_STORECHECK,
+    find: async (
+      params?: Service.ActivityStorecheck.Find.Params,
+    ): Promise<Service.ActivityStorecheck.Find.Result> => {
+      let res: Service.ActivityStorecheck.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.activityStorecheck._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.ActivityStorecheck.Get.ID,
+      params?: Service.ActivityStorecheck.Get.Params,
+    ): Promise<Service.ActivityStorecheck.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.activityStorecheck._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.ActivityStorecheck.Create.Body,
+    ): Promise<Service.ActivityStorecheck.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.activityStorecheck._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.ActivityStorecheck.Update.ID,
+      body: Service.ActivityStorecheck.Update.Body,
+    ): Promise<Service.ActivityStorecheck.Update.Result> => {
+      let res: Service.ActivityStorecheck.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.activityStorecheck._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  adjustInventory = {
+    _path: Repzo._end_points.ADJUST_INVENTORY,
+    find: async (
+      params?: Service.AdjustInventory.Find.Params,
+    ): Promise<Service.AdjustInventory.Find.Result> => {
+      let res: Service.AdjustInventory.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.adjustInventory._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.AdjustInventory.Get.ID,
+      params?: Service.AdjustInventory.Get.Params,
+    ): Promise<Service.AdjustInventory.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.adjustInventory._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.AdjustInventory.Create.Body,
+    ): Promise<Service.AdjustInventory.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.adjustInventory._path,
+        body,
+      );
+      return res;
+    },
+  };
+
+  inventory = {
+    _path: Repzo._end_points.INVENTORY,
+    find: async (
+      params?: Service.Inventory.Find.Params,
+    ): Promise<Service.Inventory.Find.Result> => {
+      let res: Service.Inventory.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.inventory._path,
+        params,
+      );
+      return res;
+    },
+  };
+
+  integrationApp = {
+    _path: Repzo._end_points.INTEGRATION_APP,
+    find: async (
+      params?: Service.App.Find.Params,
+    ): Promise<Service.App.Find.Result> => {
+      let res: Service.App.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.integrationApp._path,
+        params,
+      );
+      return res;
+    },
+
+    get: async (
+      id: Service.App.Get.ID,
+      params?: Service.App.Find.Params,
+    ): Promise<Service.App.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.integrationApp._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.App.Create.Body,
+    ): Promise<Service.App.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.integrationApp._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.App.Update.ID,
+      body: Service.App.Update.Body,
+    ): Promise<Service.App.Update.Result> => {
+      let res: Service.App.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.integrationApp._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  joinActionsWebHook = {
+    _path: Repzo._end_points.JOIN_ACTIONS_WEBHOOK,
+    update: async (
+      id: null,
+      body: Service.JoinActionsWeHook.Data,
+    ): Promise<Service.JoinActionsWeHook.Result> => {
+      let res: Service.JoinActionsWeHook.Result = await this._update(
+        this.svAPIEndpoint,
+        this.joinActionsWebHook._path,
+        body,
+      );
+      return res;
+    },
+  };
+
+  static ActionLogs = class {
+    _path: string = "integration-action-log";
+    available_app_name: string = "";
+    available_app_id: StringId = "";
+    app_id: StringId = "";
+    action: string = "";
+    status: Service.ActionLogs.Status;
+    error?: any;
+    start_time: number;
+    end_time?: number;
+    total_time?: number;
+    company_namespace?: NameSpaces;
+    body?: any;
+    meta?: any;
+    message: string;
+    details: Service.ActionLogs.Detail[];
+    sync_id: string;
+    isOld: boolean;
+    constructor(
+      public superThis: Repzo,
+      sync_id: string,
+    ) {
+      this.start_time = Date.now();
+      this.status = "processing";
+      this.message = "Log Created";
+      this.details = [];
+      this.sync_id = sync_id;
+      this.isOld = true;
+    }
+    async load(sync_id: string) {
+      const params: Service.ActionLogs.Find.Params = { sync_id: sync_id };
+      const res: Service.ActionLogs.Find.Result = await this.superThis._fetch(
+        this.superThis.svAPIEndpoint,
+        this._path,
+        params,
+      );
+      if (!res?.data?.length)
+        throw new Error(`Action Log Not found, sync_id: ${sync_id}`);
+      const action_log: Service.ActionLogs.Schema = res.data[0];
+      this.sync_id = sync_id;
+      this.details = action_log.details;
+      this.status = action_log.status;
+      this.error = action_log.error;
+      this.start_time = action_log.start_time;
+      this.body = action_log.body;
+      this.meta = action_log.meta;
+      this.message = action_log.message;
+      this.app_id = action_log.app_id;
+      this.available_app_id = action_log.available_app_id;
+      this.available_app_name = action_log.available_app_name;
+      this.company_namespace = action_log.company_namespace;
+      this.action = action_log.action;
+      this.isOld = true;
+
+      return this;
+    }
+    setStatus(status: Service.ActionLogs.Status, error?: any) {
+      this.details.push({
+        timestamp: Date.now(),
+        content: `status was changed from ${this.status} to ${status}`,
+      });
+      this.status = status;
+      if (error) {
+        if (typeof error == "string") {
+          this.error = { message: error };
+        } else if (error.message || error.response?.data) {
+          this.error = {
+            // json: error.toJSON ? error.toJSON() : undefined,
+            message: error.message,
+            responseData: error.response?.data,
+          };
+        } else {
+          this.error = error;
+        }
+        return this;
+      }
+      return this;
+    }
+    setBody(body: any) {
+      this.body = body;
+      return this;
+    }
+    setMeta(meta: any) {
+      this.meta = meta;
+      return this;
+    }
+    async commit() {
+      let doc: Service.ActionLogs.Create.Body = {
+        available_app_name: this.available_app_name,
+        available_app_id: this.available_app_id,
+        app_id: this.app_id,
+        action: this.action,
+        company_namespace: this.company_namespace,
+        status: this.status,
+        error: this.error ? this.error : undefined,
+        start_time: this.start_time,
+        end_time: Date.now(),
+        total_time: Date.now() - this.start_time,
+        body: this.body,
+        meta: this.meta,
+        message: this.message,
+        details: this.details,
+        sync_id: this.sync_id,
+      };
+      try {
+        const res: Service.ActionLogs.Create.Result =
+          await this.superThis._create(
+            this.superThis.svAPIEndpoint,
+            this._path,
+            doc,
+          );
+      } catch (e) {
+        console.error(e);
+      }
+      return this;
+    }
+    addDetail(detail: string, meta?: any) {
+      let d: Service.ActionLogs.Detail = {
+        timestamp: Date.now(),
+        content: detail,
+      };
+      this.message = detail;
+      if (meta) d.meta = meta;
+      this.details.push(d);
+      return this;
+    }
+  };
+
+  static CommandLog = class {
+    _path: string = "integration-command-log";
+    available_app_name: string;
+    available_app_id: StringId;
+    app_id: StringId;
+    command: string;
+    status: Service.CommandLog.Status;
+    error?: any;
+    start_time: number;
+    end_time?: number;
+    total_time?: number;
+    company_namespace: NameSpaces;
+    body?: any;
+    sync_details: { timestamp: number; body: { [key: string]: any } }[];
+    error_details: { timestamp: number; error: { [key: string]: any } }[];
+    meta?: any;
+    message: string;
+    details: Service.CommandLog.Detail[];
+    sync_id: string;
+    isOld: boolean;
+    priority?: number;
+    isPrioritized: boolean;
+    retries: number;
+    queuedAt?: Date;
+    failedAt?: Date;
+    succeededAt?: Date;
+    skippedAt?: Date;
+    receivedAt?: Date;
+    processedAt?: Date;
+    onGoing: boolean;
+    trigger?: string;
+    constructor(
+      public superThis: Repzo,
+      app: Service.App.Schema_with_populated_AvailableApp,
+      command: string,
+      trigger?: string,
+    ) {
+      this.app_id = app._id;
+      this.available_app_id = app.available_app._id;
+      this.available_app_name = app.available_app.name;
+      this.company_namespace = app.company_namespace;
+      this.start_time = Date.now();
+      this.status = "received";
+      this.message = "Request received";
+      this.command = command;
+      this.details = [{ timestamp: Date.now(), content: "Request received" }];
+      this.sync_id = uuid();
+      this.isOld = false;
+      this.isPrioritized = false;
+      this.retries = 1;
+      this.trigger = trigger;
+      this.onGoing = true;
+      this.sync_details = [];
+      this.error_details = [];
+    }
+    async load(sync_id?: string, retries?: number) {
+      if (sync_id) {
+        const params: Service.CommandLog.Find.Params = { sync_id: sync_id };
+        const res: Service.CommandLog.Find.Result = await this.superThis._fetch(
+          this.superThis.svAPIEndpoint,
+          this._path,
+          params,
+        );
+        if (!res?.data?.length)
+          throw new Error(`Command Log Not found, sync_id: ${sync_id}`);
+        const command_log: Service.CommandLog.Schema = res.data[0];
+
+        if (command_log) {
+          this.sync_id = sync_id;
+          this.details = command_log.details;
+          this.status = command_log.status;
+          this.error = command_log.error;
+          this.start_time = command_log.start_time;
+          this.body = command_log.body;
+          this.meta = command_log.meta;
+          this.message = command_log.message;
+          this.retries =
+            retries !== undefined
+              ? retries
+              : command_log.retries || this.retries; // retries !== undefined ? retries : command_log.retries;
+          this.isOld = true;
+          this.failedAt = command_log.failedAt;
+          this.succeededAt = command_log.succeededAt;
+          this.skippedAt = command_log.skippedAt;
+          this.receivedAt = command_log.receivedAt;
+          this.processedAt = command_log.processedAt;
+          this.onGoing = command_log.onGoing || false;
+          this.trigger = command_log.trigger;
+          this.sync_details = command_log.sync_details;
+          this.error_details = command_log.error_details;
+          // this.priority = command_log.priority
+          //   ? command_log.priority
+          //   : this.priority
+          //   ? this.priority
+          //   : undefined;
+        }
+      }
+      return this;
+    }
+    setStatus(status: Service.CommandLog.Status, error?: any) {
+      this.addDetail(`status was changed from ${this.status} to ${status}`);
+      this.status = status;
+      if (error) {
+        if (!this.error_details) this.error_details = [];
+        if (typeof error == "string") {
+          this.error = { message: error };
+        } else if (error.message || error.response?.data) {
+          this.error = {
+            // json: error.toJSON ? error.toJSON() : undefined,
+            message: error.message,
+            responseData: error.response?.data,
+          };
+        } else {
+          this.error = error;
+        }
+        this.error_details = [
+          {
+            timestamp: Date.now(),
+            error: this.error,
+          },
+        ];
+
+        return this;
+      }
+      switch (status) {
+        case "fail":
+          this.failedAt = new Date();
+          this.onGoing = false;
+          break;
+        case "processing":
+          this.processedAt = new Date();
+          this.onGoing = true;
+          break;
+        case "queued":
+          this.queuedAt = new Date();
+          this.onGoing = true;
+          break;
+        case "received":
+          this.receivedAt = new Date();
+          this.onGoing = true;
+          break;
+        case "skipped":
+          this.skippedAt = new Date();
+          this.onGoing = false;
+          break;
+        case "success":
+          this.succeededAt = new Date();
+          this.onGoing = false;
+          break;
+      }
+      return this;
+    }
+    setBody(body: any) {
+      this.body = body;
+      if (!this.sync_details) this.sync_details = [];
+      this.sync_details = [
+        {
+          timestamp: Date.now(),
+          body: this.body,
+        },
+      ];
+      return this;
+    }
+    setMeta(meta: any) {
+      this.meta = meta;
+      return this;
+    }
+    async commit() {
+      let doc: Service.CommandLog.Create.Body = {
+        available_app_name: this.available_app_name,
+        available_app_id: this.available_app_id,
+        app_id: this.app_id,
+        command: this.command,
+        status: this.status,
+        error: this.error ? this.error : undefined,
+        start_time: this.start_time,
+        end_time: Date.now(),
+        total_time: Date.now() - this.start_time,
+        company_namespace: this.company_namespace,
+        body: this.body,
+        meta: this.meta,
+        message: this.message,
+        details: this.details,
+        sync_id: this.sync_id,
+        // priority: this.priority ? this.priority : undefined,
+        queuedAt: this.queuedAt ? this.queuedAt : undefined,
+        failedAt: this.failedAt ? this.failedAt : undefined,
+        succeededAt: this.succeededAt ? this.succeededAt : undefined,
+        skippedAt: this.skippedAt ? this.skippedAt : undefined,
+        receivedAt: this.receivedAt ? this.receivedAt : undefined,
+        processedAt: this.processedAt ? this.processedAt : undefined,
+        onGoing: this.onGoing !== undefined ? this.onGoing : undefined,
+        retries: this.retries !== undefined ? this.retries : undefined,
+        trigger: this.trigger,
+        sync_details: this.sync_details,
+        error_details: this.error_details,
+      };
+      try {
+        const res: Service.CommandLog.Create.Result =
+          await this.superThis._create(
+            this.superThis.svAPIEndpoint,
+            this._path,
+            doc,
+          );
+        this.isOld = true;
+      } catch (e) {
+        console.error(e);
+      }
+      return this;
+    }
+    addDetail(detail: string, meta?: any) {
+      if (!this.details) this.details = [];
+      this.details = [
+        {
+          timestamp: Date.now(),
+          content: detail,
+          meta,
+        },
+      ];
+      this.message = detail;
+      return this;
+    }
+  };
+
+  patchAction = {
+    _path: Repzo._end_points.PATCH_ACTION,
+    create: async (
+      body: Service.PatchAction.Create.Body,
+      params?: Service.PatchAction.Create.Params,
+    ): Promise<Service.PatchAction.Create.Result> => {
+      const res: Service.PatchAction.Create.Result = await this._create(
+        this.svAPIEndpoint,
+        this.patchAction._path,
+        body,
+        params,
+      );
+      return res;
+    },
+
+    update: async (
+      body: Service.PatchAction.Update.Body,
+    ): Promise<Service.PatchAction.Update.Result> => {
+      const res: Service.PatchAction.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.patchAction._path,
+        body,
+      );
+      return res;
+    },
+  };
+
+  updateIntegrationMeta = {
+    _path: Repzo._end_points.UPDATE_INTEGRATION_META,
+    create: async (
+      body: Service.UpdateIntegrationMeta.Create.Body,
+      params?: Service.UpdateIntegrationMeta.Create.Params,
+    ): Promise<Service.UpdateIntegrationMeta.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.updateIntegrationMeta._path,
+        body,
+        params,
+      );
+      return res;
+    },
+  };
+
+  assetPartType = {
+    _path: Repzo._end_points.ASSET_PART_TYPE,
+    find: async (
+      params?: Service.AssetPartType.Find.Params,
+    ): Promise<Service.AssetPartType.Find.Result> => {
+      let res: Service.AssetPartType.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.assetPartType._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AssetPartType.Get.ID,
+    ): Promise<Service.AssetPartType.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.assetPartType._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AssetPartType.Create.Body,
+    ): Promise<Service.AssetPartType.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.assetPartType._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AssetPartType.Update.ID,
+      body: Service.AssetPartType.Update.Body,
+    ): Promise<Service.AssetPartType.Update.Result> => {
+      let res: Service.AssetPartType.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.assetPartType._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.AssetPartType.Remove.ID,
+    ): Promise<Service.AssetPartType.Remove.Result> => {
+      let res: Service.AssetPartType.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.assetPartType._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  assetPart = {
+    _path: Repzo._end_points.ASSET_PART,
+    find: async (
+      params?: Service.AssetPart.Find.Params,
+    ): Promise<Service.AssetPart.Find.Result> => {
+      let res: Service.AssetPart.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.assetPart._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AssetPart.Get.ID,
+      params?: Service.AssetPart.Get.Params,
+    ): Promise<Service.AssetPart.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.assetPart._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.AssetPart.Create.Body,
+    ): Promise<Service.AssetPart.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.assetPart._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AssetPart.Update.ID,
+      body: Service.AssetPart.Update.Body,
+    ): Promise<Service.AssetPart.Update.Result> => {
+      let res: Service.AssetPart.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.assetPart._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.AssetPart.Remove.ID,
+    ): Promise<Service.AssetPart.Remove.Result> => {
+      let res: Service.AssetPart.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.assetPart._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  assetPartUnit = {
+    _path: Repzo._end_points.ASSET_PART_UNIT,
+    find: async (
+      params?: Service.AssetPartUnit.Find.Params,
+    ): Promise<Service.AssetPartUnit.Find.Result> => {
+      let res: Service.AssetPartUnit.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.assetPartUnit._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AssetPartUnit.Get.ID,
+      params?: Service.AssetPartUnit.Get.Params,
+    ): Promise<Service.AssetPartUnit.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.assetPartUnit._path + `/${id}`,
+        params,
+      );
+    },
+    update: async (
+      id: Service.AssetPartUnit.Update.ID,
+      body: Service.AssetPartUnit.Update.Body,
+    ): Promise<Service.AssetPartUnit.Update.Result> => {
+      let res: Service.AssetPartUnit.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.assetPartUnit._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  assetPartReceival = {
+    _path: Repzo._end_points.ASSET_PART_RECEIVAL,
+    find: async (
+      params?: Service.AssetPartReceival.Find.Params,
+    ): Promise<Service.AssetPartReceival.Find.Result> => {
+      let res: Service.AssetPartReceival.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.assetPartReceival._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AssetPartReceival.Get.ID,
+      params?: Service.AssetPartReceival.Get.Params,
+    ): Promise<Service.AssetPartReceival.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.assetPartReceival._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.AssetPartReceival.Create.Body,
+    ): Promise<Service.AssetPartReceival.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.assetPartReceival._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AssetPartReceival.Update.ID,
+      body: Service.AssetPartReceival.Update.Body,
+    ): Promise<Service.AssetPartReceival.Update.Result> => {
+      let res: Service.AssetPartReceival.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.assetPartReceival._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    patch: async (
+      params: Service.AssetPartReceival.Patch.Params,
+      body: Service.AssetPartReceival.Patch.Body,
+    ): Promise<Service.AssetPartReceival.Patch.Result> => {
+      let res: Service.AssetPartReceival.Patch.Result = await this._patch(
+        this.svAPIEndpoint,
+        this.assetPartReceival._path,
+        body,
+        params,
+      );
+      return res;
+    },
+  };
+
+  assetPartTransfer = {
+    _path: Repzo._end_points.ASSET_PART_TRANSFER,
+    find: async (
+      params?: Service.AssetPartTransfer.Find.Params,
+    ): Promise<Service.AssetPartTransfer.Find.Result> => {
+      let res: Service.AssetPartTransfer.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.assetPartTransfer._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AssetPartTransfer.Get.ID,
+      params?: Service.AssetPartTransfer.Get.Params,
+    ): Promise<Service.AssetPartTransfer.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.assetPartTransfer._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.AssetPartTransfer.Create.Body,
+    ): Promise<Service.AssetPartTransfer.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.assetPartTransfer._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AssetPartTransfer.Update.ID,
+      body: Service.AssetPartTransfer.Update.Body,
+    ): Promise<Service.AssetPartTransfer.Update.Result> => {
+      let res: Service.AssetPartTransfer.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.assetPartTransfer._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    patch: async (
+      params: Service.AssetPartTransfer.Patch.Params,
+      body: Service.AssetPartTransfer.Patch.Body,
+    ): Promise<Service.AssetPartTransfer.Patch.Result> => {
+      let res: Service.AssetPartTransfer.Patch.Result = await this._patch(
+        this.svAPIEndpoint,
+        this.assetPartTransfer._path,
+        body,
+        params,
+      );
+      return res;
+    },
+  };
+
+  returnAssetPartUnit = {
+    _path: Repzo._end_points.RETURN_ASSET_PART_UNIT,
+    find: async (
+      params?: Service.ReturnAssetPartUnit.Find.Params,
+    ): Promise<Service.ReturnAssetPartUnit.Find.Result> => {
+      let res: Service.ReturnAssetPartUnit.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.returnAssetPartUnit._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.ReturnAssetPartUnit.Get.ID,
+      params?: Service.ReturnAssetPartUnit.Get.Params,
+    ): Promise<Service.ReturnAssetPartUnit.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.returnAssetPartUnit._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.ReturnAssetPartUnit.Create.Body,
+    ): Promise<Service.ReturnAssetPartUnit.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.returnAssetPartUnit._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.ReturnAssetPartUnit.Update.ID,
+      body: Service.ReturnAssetPartUnit.Update.Body,
+    ): Promise<Service.ReturnAssetPartUnit.Update.Result> => {
+      let res: Service.ReturnAssetPartUnit.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.returnAssetPartUnit._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    patch: async (
+      params: Service.ReturnAssetPartUnit.Patch.Params,
+      body: Service.ReturnAssetPartUnit.Patch.Body,
+    ): Promise<Service.ReturnAssetPartUnit.Patch.Result> => {
+      let res: Service.ReturnAssetPartUnit.Patch.Result = await this._patch(
+        this.svAPIEndpoint,
+        this.returnAssetPartUnit._path,
+        body,
+        params,
+      );
+      return res;
+    },
+  };
+
+  storeAssetPartUnit = {
+    _path: Repzo._end_points.STORE_ASSET_PART_UNIT,
+    find: async (
+      params?: Service.StoreAssetPartUnit.Find.Params,
+    ): Promise<Service.StoreAssetPartUnit.Find.Result> => {
+      let res: Service.StoreAssetPartUnit.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.storeAssetPartUnit._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.StoreAssetPartUnit.Get.ID,
+      params?: Service.StoreAssetPartUnit.Get.Params,
+    ): Promise<Service.StoreAssetPartUnit.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.storeAssetPartUnit._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.StoreAssetPartUnit.Create.Body,
+    ): Promise<Service.StoreAssetPartUnit.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.storeAssetPartUnit._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.StoreAssetPartUnit.Update.ID,
+      body: Service.StoreAssetPartUnit.Update.Body,
+    ): Promise<Service.StoreAssetPartUnit.Update.Result> => {
+      let res: Service.StoreAssetPartUnit.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.storeAssetPartUnit._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    patch: async (
+      params: Service.StoreAssetPartUnit.Patch.Params,
+      body: Service.StoreAssetPartUnit.Patch.Body,
+    ): Promise<Service.StoreAssetPartUnit.Patch.Result> => {
+      let res: Service.StoreAssetPartUnit.Patch.Result = await this._patch(
+        this.svAPIEndpoint,
+        this.storeAssetPartUnit._path,
+        body,
+        params,
+      );
+      return res;
+    },
+  };
+
+  ocrInvoiceJobTemplate = {
+    _path: Repzo._end_points.OCR_INVOICE_JOB_TEMPLATE,
+    find: async (
+      params?: Service.OcrInvoiceJobTemplate.Find.Params,
+    ): Promise<Service.OcrInvoiceJobTemplate.Find.Result> => {
+      let res: Service.OcrInvoiceJobTemplate.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJobTemplate._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.OcrInvoiceJobTemplate.Get.ID,
+    ): Promise<Service.OcrInvoiceJobTemplate.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJobTemplate._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.OcrInvoiceJobTemplate.Create.Body,
+    ): Promise<Service.OcrInvoiceJobTemplate.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJobTemplate._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.OcrInvoiceJobTemplate.Update.ID,
+      body: Service.OcrInvoiceJobTemplate.Update.Body,
+    ): Promise<Service.OcrInvoiceJobTemplate.Update.Result> => {
+      let res: Service.OcrInvoiceJobTemplate.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJobTemplate._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  ocrInvoiceJobGroup = {
+    _path: Repzo._end_points.OCR_INVOICE_JOB_GROUP,
+    find: async (
+      params?: Service.OcrInvoiceJobGroup.Find.Params,
+    ): Promise<Service.OcrInvoiceJobGroup.Find.Result> => {
+      let res: Service.OcrInvoiceJobGroup.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJobGroup._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.OcrInvoiceJobGroup.Get.ID,
+    ): Promise<Service.OcrInvoiceJobGroup.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJobGroup._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.OcrInvoiceJobGroup.Create.Body,
+    ): Promise<Service.OcrInvoiceJobGroup.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJobGroup._path,
+        body,
+      );
+      return res;
+    },
+  };
+
+  activityAiSalesOrder = {
+    _path: Repzo._end_points.ACTIVITY_AI_SALES_ORDER,
+    find: async (
+      params?: Service.ActivityAiSalesOrder.Find.Params,
+    ): Promise<Service.ActivityAiSalesOrder.Find.Result> => {
+      let res: Service.ActivityAiSalesOrder.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.activityAiSalesOrder._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.ActivityAiSalesOrder.Get.ID,
+    ): Promise<Service.ActivityAiSalesOrder.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.activityAiSalesOrder._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.ActivityAiSalesOrder.Create.Body,
+    ): Promise<Service.ActivityAiSalesOrder.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.activityAiSalesOrder._path,
+        body,
+      );
+      return res;
+    },
+  };
+
+  ocrInvoiceJob = {
+    _path: Repzo._end_points.OCR_INVOICE_JOB,
+    find: async (
+      params?: Service.OcrInvoiceJob.Find.Params,
+    ): Promise<Service.OcrInvoiceJob.Find.Result> => {
+      let res: Service.OcrInvoiceJob.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJob._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.OcrInvoiceJob.Get.ID,
+    ): Promise<Service.OcrInvoiceJob.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJob._path + `/${id}`,
+      );
+    },
+  };
+
+  ocrInvoiceJobPage = {
+    _path: Repzo._end_points.OCR_INVOICE_JOB_PAGE,
+    find: async (
+      params?: Service.OcrInvoiceJobPage.Find.Params,
+    ): Promise<Service.OcrInvoiceJobPage.Find.Result> => {
+      let res: Service.OcrInvoiceJobPage.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJobPage._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.OcrInvoiceJobPage.Get.ID,
+    ): Promise<Service.OcrInvoiceJobPage.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJobPage._path + `/${id}`,
+      );
+    },
+    update: async (
+      id: Service.OcrInvoiceJobPage.Update.ID,
+      body: Service.OcrInvoiceJobPage.Update.Body,
+    ): Promise<Service.OcrInvoiceJobPage.Update.Result> => {
+      let res: Service.OcrInvoiceJobPage.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJobPage._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  settings = {
+    _path: Repzo._end_points.SETTINGS,
+    find: async (
+      params?: Service.Settings.Find.Params,
+    ): Promise<Service.Settings.Find.Result> => {
+      let res: Service.Settings.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.settings._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.Settings.Get.ID,
+    ): Promise<Service.Settings.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.settings._path + `/${id}`,
+      );
+    },
+    update: async (
+      id: Service.Settings.Update.ID,
+      body: Service.Settings.Update.Body,
+    ): Promise<Service.Settings.Update.Result> => {
+      let res: Service.Settings.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.settings._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+  };
+
+  mailUnsubscribe = {
+    _path: Repzo._end_points.MAIL_UNSUBSCRIBE,
+
+    get: async (
+      id: Service.MailUnsubsrcibe.Get.ID,
+    ): Promise<Service.MailUnsubsrcibe.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.ocrInvoiceJobPage._path + `/${id}`,
+      );
+    },
+
+    create: async (
+      params: Service.MailUnsubsrcibe.Create.Params,
+    ): Promise<Service.MailUnsubsrcibe.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.activityAiSalesOrder._path,
+        {},
+        params,
+      );
+      return res;
+    },
+  };
+
+  approvalRequest = {
+    _path: Repzo._end_points.APPROVAL_REQUEST,
+    find: async (
+      params?: Service.ApprovalRequest.Find.Params,
+    ): Promise<Service.ApprovalRequest.Find.Result> => {
+      let res: Service.ApprovalRequest.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.approvalRequest._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.ApprovalRequest.Get.ID,
+      params?: Service.ApprovalRequest.Get.Params,
+    ): Promise<Service.ApprovalRequest.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.approvalRequest._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.ApprovalRequest.Create.Body,
+    ): Promise<Service.ApprovalRequest.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.approvalRequest._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.ApprovalRequest.Update.ID,
+      body: Service.ApprovalRequest.Update.Body,
+    ): Promise<Service.ApprovalRequest.Update.Result> => {
+      let res: Service.ApprovalRequest.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.approvalRequest._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.ApprovalRequest.Update.ID,
+      params: Service.ApprovalRequest.Remove.Params,
+    ): Promise<Service.ApprovalRequest.Remove.Result> => {
+      let res: Service.ApprovalRequest.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.approvalRequest._path + `/${id}`,
+        params,
+      );
+      return res;
+    },
+  };
+
+  safeInvoiceSerialCounter = {
+    _path: Repzo._end_points.SAFE_INVOICE_SERIAL_COUNTER,
+
+    update: async (
+      id: Service.SafeInvoiceSerialCounter.Update.ID,
+      body: Service.SafeInvoiceSerialCounter.Update.Body,
+    ): Promise<Service.SafeInvoiceSerialCounter.Update.Result> => {
+      let res: Service.SafeInvoiceSerialCounter.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.safeInvoiceSerialCounter._path + `/${id}`,
+          body,
+        );
+      return res;
+    },
+  };
+
+  clientLocation = {
+    _path: Repzo._end_points.CLIENT_LOCATION,
+    find: async (
+      params?: Service.ClientLocation.Find.Params,
+    ): Promise<Service.ClientLocation.Find.Result> => {
+      let res: Service.ClientLocation.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.clientLocation._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.ClientLocation.Get.ID,
+      params?: Service.ClientLocation.Get.Params,
+    ): Promise<Service.ClientLocation.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.clientLocation._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.ClientLocation.Create.Body,
+    ): Promise<Service.ClientLocation.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.clientLocation._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.ClientLocation.Update.ID,
+      body: Service.ClientLocation.Update.Body,
+    ): Promise<Service.ClientLocation.Update.Result> => {
+      let res: Service.ClientLocation.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.clientLocation._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.ClientLocation.Update.ID,
+      params: Service.ClientLocation.Remove.Params,
+    ): Promise<Service.ClientLocation.Remove.Result> => {
+      let res: Service.ClientLocation.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.clientLocation._path + `/${id}`,
+        params,
+      );
+      return res;
+    },
+  };
+
+  assetType = {
+    _path: Repzo._end_points.ASSET_TYPE,
+    find: async (
+      params?: Service.AssetType.Find.Params,
+    ): Promise<Service.AssetType.Find.Result> => {
+      let res: Service.AssetType.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.assetType._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AssetType.Get.ID,
+    ): Promise<Service.AssetType.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.assetType._path + `/${id}`,
+      );
+    },
+    create: async (
+      body: Service.AssetType.Create.Body,
+    ): Promise<Service.AssetType.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.assetType._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AssetType.Update.ID,
+      body: Service.AssetType.Update.Body,
+    ): Promise<Service.AssetType.Update.Result> => {
+      let res: Service.AssetType.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.assetType._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.AssetType.Update.ID,
+      params: Service.AssetType.Remove.Params,
+    ): Promise<Service.AssetType.Remove.Result> => {
+      let res: Service.AssetType.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.assetType._path + `/${id}`,
+        params,
+      );
+      return res;
+    },
+  };
+
+  asset = {
+    _path: Repzo._end_points.ASSET,
+    find: async (
+      params?: Service.Asset.Find.Params,
+    ): Promise<Service.Asset.Find.Result> => {
+      let res: Service.Asset.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.asset._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.Asset.Get.ID,
+      params?: Service.Asset.Get.Params,
+    ): Promise<Service.Asset.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.asset._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.Asset.Create.Body,
+    ): Promise<Service.Asset.Create.Result> => {
+      let res = await this._create(this.svAPIEndpoint, this.asset._path, body);
+      return res;
+    },
+    update: async (
+      id: Service.Asset.Update.ID,
+      body: Service.Asset.Update.Body,
+    ): Promise<Service.Asset.Update.Result> => {
+      let res: Service.Asset.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.asset._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.Asset.Update.ID,
+      params: Service.Asset.Remove.Params,
+    ): Promise<Service.Asset.Remove.Result> => {
+      let res: Service.Asset.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.asset._path + `/${id}`,
+        params,
+      );
+      return res;
+    },
+  };
+
+  assetUnit = {
+    _path: Repzo._end_points.ASSET_UNIT,
+    find: async (
+      params?: Service.AssetUnit.Find.Params,
+    ): Promise<Service.AssetUnit.Find.Result> => {
+      let res: Service.AssetUnit.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.assetUnit._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.AssetUnit.Get.ID,
+      params?: Service.AssetUnit.Get.Params,
+    ): Promise<Service.AssetUnit.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.assetUnit._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.AssetUnit.Create.Body,
+    ): Promise<Service.AssetUnit.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.assetUnit._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.AssetUnit.Update.ID,
+      body: Service.AssetUnit.Update.Body,
+    ): Promise<Service.AssetUnit.Update.Result> => {
+      let res: Service.AssetUnit.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.assetUnit._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.AssetUnit.Update.ID,
+      params: Service.AssetUnit.Remove.Params,
+    ): Promise<Service.AssetUnit.Remove.Result> => {
+      let res: Service.AssetUnit.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.assetUnit._path + `/${id}`,
+        params,
+      );
+      return res;
+    },
+  };
+
+  workorderPortal = {
+    _path: Repzo._end_points.WORKORDER_PORTAL,
+    find: async (
+      params?: Service.WorkorderPortal.Find.Params,
+    ): Promise<Service.WorkorderPortal.Find.Result> => {
+      let res: Service.WorkorderPortal.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.workorderPortal._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.WorkorderPortal.Get.ID,
+      params?: Service.WorkorderPortal.Get.Params,
+    ): Promise<Service.WorkorderPortal.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.workorderPortal._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.WorkorderPortal.Create.Body,
+    ): Promise<Service.WorkorderPortal.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.workorderPortal._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.WorkorderPortal.Update.ID,
+      body: Service.WorkorderPortal.Update.Body,
+    ): Promise<Service.WorkorderPortal.Update.Result> => {
+      let res: Service.WorkorderPortal.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.workorderPortal._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.WorkorderPortal.Update.ID,
+    ): Promise<Service.WorkorderPortal.Remove.Result> => {
+      let res: Service.WorkorderPortal.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.workorderPortal._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  approval = {
+    _path: Repzo._end_points.APPROVAL,
+    find: async (
+      params?: Service.Approval.Find.Params,
+    ): Promise<Service.Approval.Find.Result> => {
+      let res: Service.Approval.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.approval._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.Approval.Get.ID,
+      params?: Service.Approval.Get.Params,
+    ): Promise<Service.Approval.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.approval._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.Approval.Create.Body,
+    ): Promise<Service.Approval.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.approval._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.Approval.Update.ID,
+      body: Service.Approval.Update.Body,
+    ): Promise<Service.Approval.Update.Result> => {
+      let res: Service.Approval.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.approval._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.Approval.Remove.ID,
+    ): Promise<Service.Approval.Remove.Result> => {
+      let res: Service.Approval.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.approval._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  workorderCategory = {
+    _path: Repzo._end_points.WORKORDER_CATEGORY,
+    find: async (
+      params?: Service.WorkorderCategory.Find.Params,
+    ): Promise<Service.WorkorderCategory.Find.Result> => {
+      let res: Service.WorkorderCategory.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.workorderCategory._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.WorkorderCategory.Get.ID,
+      params?: Service.WorkorderCategory.Get.Params,
+    ): Promise<Service.WorkorderCategory.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.workorderCategory._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.WorkorderCategory.Create.Body,
+    ): Promise<Service.WorkorderCategory.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.workorderCategory._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.WorkorderCategory.Update.ID,
+      body: Service.WorkorderCategory.Update.Body,
+    ): Promise<Service.WorkorderCategory.Update.Result> => {
+      let res: Service.WorkorderCategory.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.workorderCategory._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.WorkorderCategory.Remove.ID,
+    ): Promise<Service.WorkorderCategory.Remove.Result> => {
+      let res: Service.WorkorderCategory.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.workorderCategory._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  contract = {
+    _path: Repzo._end_points.CONTRACT,
+    find: async (
+      params?: Service.Contract.Find.Params,
+    ): Promise<Service.Contract.Find.Result> => {
+      let res: Service.Contract.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.contract._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.Contract.Get.ID,
+      params?: Service.Contract.Get.Params,
+    ): Promise<Service.Contract.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.contract._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.Contract.Create.Body,
+    ): Promise<Service.Contract.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.contract._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.Contract.Update.ID,
+      body: Service.Contract.Update.Body,
+    ): Promise<Service.Contract.Update.Result> => {
+      let res: Service.Contract.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.contract._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.Contract.Remove.ID,
+    ): Promise<Service.Contract.Remove.Result> => {
+      let res: Service.Contract.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.contract._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  contractInstallment = {
+    _path: Repzo._end_points.CONTRACT_INSTALLMENT,
+    find: async (
+      params?: Service.ContractInstallment.Find.Params,
+    ): Promise<Service.ContractInstallment.Find.Result> => {
+      let res: Service.ContractInstallment.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.contractInstallment._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.ContractInstallment.Get.ID,
+      params?: Service.ContractInstallment.Get.Params,
+    ): Promise<Service.ContractInstallment.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.contractInstallment._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.ContractInstallment.Create.Body,
+    ): Promise<Service.ContractInstallment.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.contractInstallment._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.ContractInstallment.Update.ID,
+      body: Service.ContractInstallment.Update.Body,
+    ): Promise<Service.ContractInstallment.Update.Result> => {
+      let res: Service.ContractInstallment.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.contractInstallment._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.ContractInstallment.Remove.ID,
+    ): Promise<Service.ContractInstallment.Remove.Result> => {
+      let res: Service.ContractInstallment.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.contractInstallment._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  repBalanceSummary = {
+    _path: Repzo._end_points.REP_BALANCE_SUMMARY,
+    find: async (
+      params: Service.RepBalanceSummary.Find.Params,
+    ): Promise<Service.RepBalanceSummary.Find.Result> => {
+      let res: Service.RepBalanceSummary.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.repBalanceSummary._path,
+        params,
+      );
+      return res;
+    },
+  };
+
+  workorderPortalLink = {
+    _path: Repzo._end_points.WORKORDER_PORTAL_LINK,
+    find: async (
+      params?: Service.WorkorderPortalLink.Find.Params,
+    ): Promise<Service.WorkorderPortalLink.Find.Result> => {
+      let res: Service.WorkorderPortalLink.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.workorderPortalLink._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.WorkorderPortalLink.Get.ID,
+      params?: Service.WorkorderPortalLink.Get.Params,
+    ): Promise<Service.WorkorderPortalLink.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.workorderPortalLink._path + `/${id}`,
+        params,
+      );
+    },
+
+    create: async (
+      body: Service.WorkorderPortalLink.Create.Body,
+    ): Promise<Service.WorkorderPortalLink.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.workorderPortalLink._path,
+        body,
+      );
+      return res;
+    },
+
+    update: async (
+      id: Service.WorkorderPortalLink.Update.ID,
+      body: Service.WorkorderPortalLink.Update.Body,
+    ): Promise<Service.WorkorderPortalLink.Update.Result> => {
+      let res: Service.WorkorderPortalLink.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.workorderPortalLink._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    patch: async (
+      id: Service.WorkorderPortalLink.Patch.ID,
+      body: Service.WorkorderPortalLink.Patch.Body,
+    ): Promise<Service.WorkorderPortalLink.Patch.Result> => {
+      let res: Service.WorkorderPortalLink.Patch.Result = await this._patch(
+        this.svAPIEndpoint,
+        this.workorderPortalLink._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+
+    remove: async (
+      id: Service.WorkorderPortalLink.Remove.ID,
+    ): Promise<Service.WorkorderPortalLink.Remove.Result> => {
+      let res: Service.WorkorderPortalLink.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.workorderPortalLink._path + `/${id}`,
+      );
+      return res;
+    },
+  };
+
+  customField = {
+    _path: Repzo._end_points.CUSTOM_FIELD,
+    find: async (
+      params?: Service.CustomField.Find.Params,
+    ): Promise<Service.CustomField.Find.Result> => {
+      let res: Service.CustomField.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.customField._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.CustomField.Get.ID,
+      params?: Service.CustomField.Get.Params,
+    ): Promise<Service.CustomField.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.customField._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.CustomField.Create.Body,
+    ): Promise<Service.CustomField.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.customField._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.CustomField.Update.ID,
+      body: Service.CustomField.Update.Body,
+    ): Promise<Service.CustomField.Update.Result> => {
+      let res: Service.CustomField.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.customField._path + `/${id}`,
+        body,
+      );
+      return res;
+    },
+    remove: async (
+      id: Service.CustomField.Update.ID,
+      params: Service.CustomField.Remove.Params,
+    ): Promise<Service.CustomField.Remove.Result> => {
+      let res: Service.CustomField.Remove.Result = await this._delete(
+        this.svAPIEndpoint,
+        this.customField._path + `/${id}`,
+        params,
+      );
+      return res;
+    },
+  };
+
+  timelineReport = {
+    _path: Repzo._end_points.TIMELINE_REPORT,
+    find: async (
+      params?: Service.TimelineReport.Find.Params,
+    ): Promise<Service.TimelineReport.Find.Result> => {
+      let res: Service.TimelineReport.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.timelineReport._path,
+        params,
+      );
+      return res;
+    },
+  };
+
+  resetCompanyNamespace = {
+    _path: Repzo._end_points.RESET_COMPANY_NAMESPACE,
+    find: async (
+      params?: Service.ResetCompanyNamespace.Find.Params,
+    ): Promise<Service.ResetCompanyNamespace.Find.Result> => {
+      let res: Service.ResetCompanyNamespace.Find.Result = await this._fetch(
+        this.svAPIEndpoint,
+        this.resetCompanyNamespace._path,
+        params,
+      );
+      return res;
+    },
+    get: async (
+      id: Service.ResetCompanyNamespace.Get.ID,
+      params?: Service.ResetCompanyNamespace.Get.Params,
+    ): Promise<Service.ResetCompanyNamespace.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.resetCompanyNamespace._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.ResetCompanyNamespace.Create.Body,
+    ): Promise<Service.ResetCompanyNamespace.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.resetCompanyNamespace._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.ResetCompanyNamespace.Update.ID,
+    ): Promise<Service.ResetCompanyNamespace.Update.Result> => {
+      let res: Service.ResetCompanyNamespace.Update.Result = await this._update(
+        this.svAPIEndpoint,
+        this.resetCompanyNamespace._path + `/${id}`,
+        {},
+      );
+      return res;
+    },
+  };
+
+  testResetCompanyNamespace = {
+    _path: Repzo._end_points.TEST_RESET_COMPANY_NAMESPACE,
+    find: async (
+      params?: Service.TestResetCompanyNamespace.Find.Params,
+    ): Promise<Service.TestResetCompanyNamespace.Find.Result> => {
+      let res: Service.TestResetCompanyNamespace.Find.Result =
+        await this._fetch(
+          this.svAPIEndpoint,
+          this.testResetCompanyNamespace._path,
+          params,
+        );
+      return res;
+    },
+    get: async (
+      id: Service.TestResetCompanyNamespace.Get.ID,
+      params?: Service.TestResetCompanyNamespace.Get.Params,
+    ): Promise<Service.TestResetCompanyNamespace.Get.Result> => {
+      return await this._fetch(
+        this.svAPIEndpoint,
+        this.testResetCompanyNamespace._path + `/${id}`,
+        params,
+      );
+    },
+    create: async (
+      body: Service.TestResetCompanyNamespace.Create.Body,
+    ): Promise<Service.TestResetCompanyNamespace.Create.Result> => {
+      let res = await this._create(
+        this.svAPIEndpoint,
+        this.testResetCompanyNamespace._path,
+        body,
+      );
+      return res;
+    },
+    update: async (
+      id: Service.TestResetCompanyNamespace.Update.ID,
+    ): Promise<Service.TestResetCompanyNamespace.Update.Result> => {
+      let res: Service.TestResetCompanyNamespace.Update.Result =
+        await this._update(
+          this.svAPIEndpoint,
+          this.testResetCompanyNamespace._path + `/${id}`,
+          {},
+        );
+      return res;
+    },
+  };
+}
+
+function normalizeParams(params: Params): { [key: string]: any } {
+  const normalized: Record<string, any> = {};
+
+  for (const key in params) {
+    const value = params[key];
+
+    if (value === undefined || value === null) continue;
+
+    if (
+      typeof value === "object" &&
+      !(value instanceof Date) &&
+      !(value instanceof String)
+    ) {
+      normalized[key] = JSON.stringify(value);
+    } else {
+      normalized[key] = value;
+    }
+  }
+
+  return normalized;
+}