/**
 * fulfillmenttools - simplifying retail complexity
 * This is the fulfillmenttools API documentation. Visit https://docs.fulfillmenttools.com/ for first steps.
 *
 * OpenAPI spec version: VERSIONLESS
 * Contact: api@fulfillmenttools.com
 *
 * NOTE: This file is auto generated by the swagger code generator program.
 * https://github.com/swagger-api/swagger-codegen.git
 * Do not edit the file manually.
 */

import * as api from "./api"
import { Configuration } from "./configuration"

const config: Configuration = {}

describe("CoreConfigurationApi", () => {
  let instance: api.CoreConfigurationApi
  beforeEach(function() {
    instance = new api.CoreConfigurationApi(config)
  });

  test("getExpiryConfiguration", () => {
    return expect(instance.getExpiryConfiguration({})).resolves.toBe(null)
  })
  test("getGdprConfiguration", () => {
    return expect(instance.getGdprConfiguration({})).resolves.toBe(null)
  })
  test("getLocaleConfiguration", () => {
    return expect(instance.getLocaleConfiguration({})).resolves.toBe(null)
  })
  test("getLocales", () => {
    return expect(instance.getLocales({})).resolves.toBe(null)
  })
  test("getTenantConfiguration", () => {
    return expect(instance.getTenantConfiguration({})).resolves.toBe(null)
  })
  test("putGdprConfiguration", () => {
    const body: api.GdprConfiguration = undefined
    return expect(instance.putGdprConfiguration(body, {})).resolves.toBe(null)
  })
  test("putLocaleConfiguration", () => {
    const body: api.LocaleConfiguration = undefined
    return expect(instance.putLocaleConfiguration(body, {})).resolves.toBe(null)
  })
  test("putTenantConfiguration", () => {
    const body: api.TenantConfigurationForUpsert = undefined
    return expect(instance.putTenantConfiguration(body, {})).resolves.toBe(null)
  })
  test("upsertExpiryConfiguration", () => {
    const body: api.ExpiryConfiguration = undefined
    return expect(instance.upsertExpiryConfiguration(body, {})).resolves.toBe(null)
  })
})

describe("CoreCustomServicesApi", () => {
  let instance: api.CoreCustomServicesApi
  beforeEach(function() {
    instance = new api.CoreCustomServicesApi(config)
  });

  test("createCustomService", () => {
    const body: api.CustomServiceForCreation = undefined
    return expect(instance.createCustomService(body, {})).resolves.toBe(null)
  })
  test("createCustomServiceAdditionalInformation", () => {
    const body: api.AdditionalInformationForCreation = undefined
    const customServiceId: string = "customServiceId_example"
    return expect(instance.createCustomServiceAdditionalInformation(body, customServiceId, {})).resolves.toBe(null)
  })
  test("deleteAdditionalInfo", () => {
    const customServiceId: string = "customServiceId_example"
    const additionalInformationId: string = "additionalInformationId_example"
    return expect(instance.deleteAdditionalInfo(customServiceId, additionalInformationId, {})).resolves.toBe(null)
  })
  test("getCustomService", () => {
    const customServiceId: string = "customServiceId_example"
    return expect(instance.getCustomService(customServiceId, {})).resolves.toBe(null)
  })
  test("getCustomServices", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getCustomServices(startAfterId, size, {})).resolves.toBe(null)
  })
  test("patchCustomService", () => {
    const body: api.CustomServicePatchActions = undefined
    const customServiceId: string = "customServiceId_example"
    return expect(instance.patchCustomService(body, customServiceId, {})).resolves.toBe(null)
  })
  test("updateCustomServiceAdditionalInformation", () => {
    const body: api.AdditionalInformationForCreation = undefined
    const customServiceId: string = "customServiceId_example"
    const additionalInformationId: string = "additionalInformationId_example"
    return expect(instance.updateCustomServiceAdditionalInformation(body, customServiceId, additionalInformationId, {})).resolves.toBe(null)
  })
})

describe("CoreDocumentSetsApi", () => {
  let instance: api.CoreDocumentSetsApi
  beforeEach(function() {
    instance = new api.CoreDocumentSetsApi(config)
  });

  test("addContentToDocument", () => {
    const body: api.ExternalDocumentContentForUpdate = undefined
    const documentSetRef: string = "documentSetRef_example"
    const documentRef: string = "documentRef_example"
    return expect(instance.addContentToDocument(body, documentSetRef, documentRef, {})).resolves.toBe(null)
  })
  test("addContentToDocumentDeprecated", () => {
    const body: api.ExternalDocumentContentForUpdate = undefined
    const documentSetRef: string = "documentSetRef_example"
    const documentRef: string = "documentRef_example"
    return expect(instance.addContentToDocumentDeprecated(body, documentSetRef, documentRef, {})).resolves.toBe(null)
  })
  test("addDocument", () => {
    const body: api.ExternalPrintableDocumentForCreation = undefined
    const documentSetRef: string = "documentSetRef_example"
    return expect(instance.addDocument(body, documentSetRef, {})).resolves.toBe(null)
  })
  test("addDocumentDeprecated", () => {
    const body: api.ExternalPrintableDocumentForCreation = undefined
    const documentSetRef: string = "documentSetRef_example"
    return expect(instance.addDocumentDeprecated(body, documentSetRef, {})).resolves.toBe(null)
  })
  test("downloadDocument", () => {
    const documentSetRef: string = "documentSetRef_example"
    const documentRef: string = "documentRef_example"
    return expect(instance.downloadDocument(documentSetRef, documentRef, {})).resolves.toBe(null)
  })
  test("downloadDocumentDeprecated", () => {
    const documentSetRef: string = "documentSetRef_example"
    const documentRef: string = "documentRef_example"
    return expect(instance.downloadDocumentDeprecated(documentSetRef, documentRef, {})).resolves.toBe(null)
  })
  test("getDocumentSet", () => {
    const documentSetRef: string = "documentSetRef_example"
    return expect(instance.getDocumentSet(documentSetRef, {})).resolves.toBe(null)
  })
  test("getDocumentSetDeprecated", () => {
    const documentSetRef: string = "documentSetRef_example"
    return expect(instance.getDocumentSetDeprecated(documentSetRef, {})).resolves.toBe(null)
  })
  test("updateDocument", () => {
    const body: api.PrintableDocumentForUpdate = undefined
    const documentSetRef: string = "documentSetRef_example"
    const documentRef: string = "documentRef_example"
    return expect(instance.updateDocument(body, documentSetRef, documentRef, {})).resolves.toBe(null)
  })
  test("updateDocumentDeprecated", () => {
    const body: api.PrintableDocumentForUpdate = undefined
    const documentSetRef: string = "documentSetRef_example"
    const documentRef: string = "documentRef_example"
    return expect(instance.updateDocumentDeprecated(body, documentSetRef, documentRef, {})).resolves.toBe(null)
  })
})

describe("CoreEventingApi", () => {
  let instance: api.CoreEventingApi
  beforeEach(function() {
    instance = new api.CoreEventingApi(config)
  });

  test("addSubscription", () => {
    const body: api.SubscriptionForCreation = undefined
    return expect(instance.addSubscription(body, {})).resolves.toBe(null)
  })
  test("deleteSubscription", () => {
    const subscriptionId: string = "subscriptionId_example"
    return expect(instance.deleteSubscription(subscriptionId, {})).resolves.toBe(null)
  })
  test("getEvents", () => {
    return expect(instance.getEvents({})).resolves.toBe(null)
  })
  test("getSubscriptions", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getSubscriptions(startAfterId, size, {})).resolves.toBe(null)
  })
})

describe("CoreExpiriesApi", () => {
  let instance: api.CoreExpiriesApi
  beforeEach(function() {
    instance = new api.CoreExpiriesApi(config)
  });

  test("createExpiry", () => {
    const body: api.ExpiryEntityForCreation = undefined
    return expect(instance.createExpiry(body, {})).resolves.toBe(null)
  })
  test("getExpiries", () => {
    const status: ExpiryEntityStatus = undefined
    const processRef: string = "processRef_example"
    const startDate: Date = 2013-10-20T19:20:30+01:00
    const endDate: string = "endDate_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getExpiries(status, processRef, startDate, endDate, startAfterId, size, {})).resolves.toBe(null)
  })
  test("getExpiry", () => {
    const expiryId: string = "expiryId_example"
    return expect(instance.getExpiry(expiryId, {})).resolves.toBe(null)
  })
  test("updateExpiry", () => {
    const expiryId: string = "expiryId_example"
    const body: api.ExpiryEntityForUpdate = undefined
    return expect(instance.updateExpiry(expiryId, body, {})).resolves.toBe(null)
  })
})

describe("CoreFacilitiesApi", () => {
  let instance: api.CoreFacilitiesApi
  beforeEach(function() {
    instance = new api.CoreFacilitiesApi(config)
  });

  test("addFacility", () => {
    const body: api.FacilityForCreation = undefined
    return expect(instance.addFacility(body, {})).resolves.toBe(null)
  })
  test("connectCarrierToFacility", () => {
    const body: api.FacilityCarrierConnectionForModification = undefined
    const facilityId: string = "facilityId_example"
    const carrierRef: string = "carrierRef_example"
    const locale: string = "locale_example"
    return expect(instance.connectCarrierToFacility(body, facilityId, carrierRef, locale, {})).resolves.toBe(null)
  })
  test("createCarrierToFacility", () => {
    const body: api.FacilityCarrierConnectionForCreation = undefined
    const facilityId: string = "facilityId_example"
    const carrierRef: string = "carrierRef_example"
    const locale: string = "locale_example"
    return expect(instance.createCarrierToFacility(body, facilityId, carrierRef, locale, {})).resolves.toBe(null)
  })
  test("createFacilityCustomServiceConnection", () => {
    const body: api.FacilityCustomServiceConnectionForCreation = undefined
    const facilityId: string = "facilityId_example"
    const customServiceId: string = "customServiceId_example"
    return expect(instance.createFacilityCustomServiceConnection(body, facilityId, customServiceId, {})).resolves.toBe(null)
  })
  test("deleteFacility", () => {
    const facilityId: string = "facilityId_example"
    const forceDeletion: boolean = true
    return expect(instance.deleteFacility(facilityId, forceDeletion, {})).resolves.toBe(null)
  })
  test("deleteFacilityCustomServiceConnection", () => {
    const facilityId: string = "facilityId_example"
    const customServiceId: string = "customServiceId_example"
    return expect(instance.deleteFacilityCustomServiceConnection(facilityId, customServiceId, {})).resolves.toBe(null)
  })
  test("deleteFacilityStorageLocation", () => {
    const facilityId: string = "facilityId_example"
    const storageLocationId: string = "storageLocationId_example"
    return expect(instance.deleteFacilityStorageLocation(facilityId, storageLocationId, {})).resolves.toBe(null)
  })
  test("deleteFacilityZone", () => {
    const facilityId: string = "facilityId_example"
    const zoneId: string = "zoneId_example"
    return expect(instance.deleteFacilityZone(facilityId, zoneId, {})).resolves.toBe(null)
  })
  test("facilityAction", () => {
    const facilityId: string = "facilityId_example"
    const body: api.FacilityActionsParameter = undefined
    return expect(instance.facilityAction(facilityId, body, {})).resolves.toBe(null)
  })
  test("getAllFacilities", () => {
    const startAfterId: string = "startAfterId_example"
    const status: Array<string> = undefined
    const size: number = 56
    const tenantFacilityId: string = "tenantFacilityId_example"
    const orderBy: FacilityOrderBy = undefined
    return expect(instance.getAllFacilities(startAfterId, status, size, tenantFacilityId, orderBy, {})).resolves.toBe(null)
  })
  test("getFacility", () => {
    const facilityId: string = "facilityId_example"
    return expect(instance.getFacility(facilityId, {})).resolves.toBe(null)
  })
  test("getFacilityCarrier", () => {
    const facilityId: string = "facilityId_example"
    const carrierRef: string = "carrierRef_example"
    const locale: string = "locale_example"
    return expect(instance.getFacilityCarrier(facilityId, carrierRef, locale, {})).resolves.toBe(null)
  })
  test("getFacilityCeps", () => {
    const facilityId: string = "facilityId_example"
    return expect(instance.getFacilityCeps(facilityId, {})).resolves.toBe(null)
  })
  test("getFacilityCustomService", () => {
    const facilityId: string = "facilityId_example"
    const customServiceId: string = "customServiceId_example"
    return expect(instance.getFacilityCustomService(facilityId, customServiceId, {})).resolves.toBe(null)
  })
  test("getFacilityCustomServiceConnections", () => {
    const facilityId: string = "facilityId_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getFacilityCustomServiceConnections(facilityId, startAfterId, size, {})).resolves.toBe(null)
  })
  test("getFacilityStorageLocation", () => {
    const facilityId: string = "facilityId_example"
    const storageLocationId: string = "storageLocationId_example"
    return expect(instance.getFacilityStorageLocation(facilityId, storageLocationId, {})).resolves.toBe(null)
  })
  test("getFacilityStorageLocations", () => {
    const facilityId: string = "facilityId_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const scannableCode: string = "scannableCode_example"
    return expect(instance.getFacilityStorageLocations(facilityId, startAfterId, size, scannableCode, {})).resolves.toBe(null)
  })
  test("getFacilityZone", () => {
    const facilityId: string = "facilityId_example"
    const zoneId: string = "zoneId_example"
    return expect(instance.getFacilityZone(facilityId, zoneId, {})).resolves.toBe(null)
  })
  test("getFacilityZones", () => {
    const facilityId: string = "facilityId_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getFacilityZones(facilityId, startAfterId, size, {})).resolves.toBe(null)
  })
  test("patchFacility", () => {
    const body: api.FacilityPatchActions = undefined
    const facilityId: string = "facilityId_example"
    return expect(instance.patchFacility(body, facilityId, {})).resolves.toBe(null)
  })
  test("patchFacilityStorageLocation", () => {
    const body: api.StorageLocationPatchActions = undefined
    const facilityId: string = "facilityId_example"
    const storageLocationId: string = "storageLocationId_example"
    return expect(instance.patchFacilityStorageLocation(body, facilityId, storageLocationId, {})).resolves.toBe(null)
  })
  test("postFacilityStorageLocations", () => {
    const body: api.StorageLocationForCreation = undefined
    const facilityId: string = "facilityId_example"
    return expect(instance.postFacilityStorageLocations(body, facilityId, {})).resolves.toBe(null)
  })
  test("postFacilityZone", () => {
    const body: api.ZoneForCreation = undefined
    const facilityId: string = "facilityId_example"
    return expect(instance.postFacilityZone(body, facilityId, {})).resolves.toBe(null)
  })
  test("putFacilityStorageLocation", () => {
    const body: api.StorageLocationForReplacement = undefined
    const facilityId: string = "facilityId_example"
    const storageLocationId: string = "storageLocationId_example"
    return expect(instance.putFacilityStorageLocation(body, facilityId, storageLocationId, {})).resolves.toBe(null)
  })
  test("putFacilityZone", () => {
    const body: api.ZoneForReplacement = undefined
    const facilityId: string = "facilityId_example"
    const zoneId: string = "zoneId_example"
    return expect(instance.putFacilityZone(body, facilityId, zoneId, {})).resolves.toBe(null)
  })
  test("updateFacilityCustomServiceConnction", () => {
    const body: api.FacilityCustomServiceConnectionForUpdate = undefined
    const facilityId: string = "facilityId_example"
    const customServiceId: string = "customServiceId_example"
    return expect(instance.updateFacilityCustomServiceConnction(body, facilityId, customServiceId, {})).resolves.toBe(null)
  })
})

describe("CoreListingsApi", () => {
  let instance: api.CoreListingsApi
  beforeEach(function() {
    instance = new api.CoreListingsApi(config)
  });

  test("createMeasurementUnit", () => {
    const body: api.MeasurementUnitForCreation = undefined
    return expect(instance.createMeasurementUnit(body, {})).resolves.toBe(null)
  })
  test("deleteFacilityListing", () => {
    const facilityId: string = "facilityId_example"
    const tenantArticleId: string = "tenantArticleId_example"
    return expect(instance.deleteFacilityListing(facilityId, tenantArticleId, {})).resolves.toBe(null)
  })
  test("deleteFacilityListingPartialStock", () => {
    const facilityId: string = "facilityId_example"
    const tenantArticleId: string = "tenantArticleId_example"
    return expect(instance.deleteFacilityListingPartialStock(facilityId, tenantArticleId, {})).resolves.toBe(null)
  })
  test("deleteListingsOfFacility", () => {
    const facilityId: string = "facilityId_example"
    return expect(instance.deleteListingsOfFacility(facilityId, {})).resolves.toBe(null)
  })
  test("deleteMeasurementUnit", () => {
    const measurementUnitId: string = "measurementUnitId_example"
    return expect(instance.deleteMeasurementUnit(measurementUnitId, {})).resolves.toBe(null)
  })
  test("getAllMeasurementUnits", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const key: string = "key_example"
    const locale: string = "locale_example"
    return expect(instance.getAllMeasurementUnits(startAfterId, size, key, locale, {})).resolves.toBe(null)
  })
  test("getFacilityListing", () => {
    const facilityId: string = "facilityId_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const tenantArticleIds: Array<string> = undefined
    const scannableCode: string = "scannableCode_example"
    return expect(instance.getFacilityListing(facilityId, startAfterId, size, tenantArticleIds, scannableCode, {})).resolves.toBe(null)
  })
  test("getFacilityListingPartialStock", () => {
    const facilityId: string = "facilityId_example"
    const tenantArticleId: string = "tenantArticleId_example"
    return expect(instance.getFacilityListingPartialStock(facilityId, tenantArticleId, {})).resolves.toBe(null)
  })
  test("getListing", () => {
    const facilityId: string = "facilityId_example"
    const tenantArticleId: string = "tenantArticleId_example"
    const locale: string = "locale_example"
    return expect(instance.getListing(facilityId, tenantArticleId, locale, {})).resolves.toBe(null)
  })
  test("getMeasurementUnitByID", () => {
    const measurementUnitId: string = "measurementUnitId_example"
    return expect(instance.getMeasurementUnitByID(measurementUnitId, {})).resolves.toBe(null)
  })
  test("patchFacilityListing", () => {
    const body: api.ListingPatchActions = undefined
    const facilityId: string = "facilityId_example"
    const tenantArticleId: string = "tenantArticleId_example"
    return expect(instance.patchFacilityListing(body, facilityId, tenantArticleId, {})).resolves.toBe(null)
  })
  test("patchFacilityListingPartialStock", () => {
    const body: api.PartialStockPatchActions = undefined
    const facilityId: string = "facilityId_example"
    const tenantArticleId: string = "tenantArticleId_example"
    return expect(instance.patchFacilityListingPartialStock(body, facilityId, tenantArticleId, {})).resolves.toBe(null)
  })
  test("putFacilityListing", () => {
    const body: api.ListingsForReplacement = undefined
    const facilityId: string = "facilityId_example"
    return expect(instance.putFacilityListing(body, facilityId, {})).resolves.toBe(null)
  })
  test("putFacilityListingPartialStock", () => {
    const body: api.PartialStocksForReplacement = undefined
    const facilityId: string = "facilityId_example"
    const tenantArticleId: string = "tenantArticleId_example"
    return expect(instance.putFacilityListingPartialStock(body, facilityId, tenantArticleId, {})).resolves.toBe(null)
  })
  test("updateMeasurementUnit", () => {
    const body: api.MeasurementUnitForCreation = undefined
    const measurementUnitId: string = "measurementUnitId_example"
    return expect(instance.updateMeasurementUnit(body, measurementUnitId, {})).resolves.toBe(null)
  })
})

describe("CoreNotificationCenterApi", () => {
  let instance: api.CoreNotificationCenterApi
  beforeEach(function() {
    instance = new api.CoreNotificationCenterApi(config)
  });

  test("deleteNotificationCenterConfigChannel", () => {
    const channelId: string = "channelId_example"
    const version: number = 1.2
    return expect(instance.deleteNotificationCenterConfigChannel(channelId, version, {})).resolves.toBe(null)
  })
  test("deleteNotificationCenterFacilityConfigChannel", () => {
    const facilityRef: string = "facilityRef_example"
    const channelId: string = "channelId_example"
    const version: number = 1.2
    return expect(instance.deleteNotificationCenterFacilityConfigChannel(facilityRef, channelId, version, {})).resolves.toBe(null)
  })
  test("executeNotificationCenterConfigAction", () => {
    const body: api.NotificationsActionsBody = undefined
    return expect(instance.executeNotificationCenterConfigAction(body, {})).resolves.toBe(null)
  })
  test("executeNotificationCenterFacilityConfigAction", () => {
    const body: api.NotificationsActionsBody1 = undefined
    const facilityRef: string = "facilityRef_example"
    return expect(instance.executeNotificationCenterFacilityConfigAction(body, facilityRef, {})).resolves.toBe(null)
  })
  test("getNotificationCenterConfig", () => {
    return expect(instance.getNotificationCenterConfig({})).resolves.toBe(null)
  })
  test("getNotificationCenterFacilityConfig", () => {
    const facilityRef: string = "facilityRef_example"
    return expect(instance.getNotificationCenterFacilityConfig(facilityRef, {})).resolves.toBe(null)
  })
  test("upsertNotificationCenterConfig", () => {
    const body: api.ConfigurationsNotificationsBody = undefined
    return expect(instance.upsertNotificationCenterConfig(body, {})).resolves.toBe(null)
  })
  test("upsertNotificationCenterFacilityConfig", () => {
    const body: api.ConfigurationsNotificationsBody1 = undefined
    const facilityRef: string = "facilityRef_example"
    return expect(instance.upsertNotificationCenterFacilityConfig(body, facilityRef, {})).resolves.toBe(null)
  })
})

describe("CoreProcessesApi", () => {
  let instance: api.CoreProcessesApi
  beforeEach(function() {
    instance = new api.CoreProcessesApi(config)
  });

  test("addDocumentToProcess", () => {
    const body: api.ExternalDocumentForCreation = undefined
    const processId: string = "processId_example"
    return expect(instance.addDocumentToProcess(body, processId, {})).resolves.toBe(null)
  })
  test("downloadDocumentInProcess", () => {
    const processId: string = "processId_example"
    const documentId: string = "documentId_example"
    return expect(instance.downloadDocumentInProcess(processId, documentId, {})).resolves.toBe(null)
  })
  test("downloadProcessDocument", () => {
    const documentId: string = "documentId_example"
    return expect(instance.downloadProcessDocument(documentId, {})).resolves.toBe(null)
  })
  test("getAllBrands", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getAllBrands(startAfterId, size, {})).resolves.toBe(null)
  })
  test("getAllProcesses", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const status: Array<string> = undefined
    const operativeStatus: Array<string> = undefined
    const tenantOrderId: string = "tenantOrderId_example"
    const startTargetTime: Date = 2013-10-20T19:20:30+01:00
    const endTargetTime: Date = 2013-10-20T19:20:30+01:00
    const startDate: Date = 2013-10-20T19:20:30+01:00
    const endDate: Date = 2013-10-20T19:20:30+01:00
    const facilityRefs: Array<string> = undefined
    const countries: Array<string> = undefined
    const facilityCountries: Array<string> = undefined
    const brandRefs: Array<string> = undefined
    const serviceLevels: Array<string> = undefined
    const serviceTypes: Array<string> = undefined
    const orderDomainStatus: Array<string> = undefined
    const routingDomainStatus: Array<string> = undefined
    const pickingDomainStatus: Array<string> = undefined
    const packingDomainStatus: Array<string> = undefined
    const shippingDomainStatus: Array<string> = undefined
    const handoverDomainStatus: Array<string> = undefined
    const returnDomainStatus: Array<string> = undefined
    const stickers: Array<string> = undefined
    const searchTerm: string = "searchTerm_example"
    const sortBy: SortParameterName = undefined
    const sortByDirection: SortDirection = undefined
    const locked: boolean = true
    const orderStatus: OrderStatus = undefined
    return expect(instance.getAllProcesses(startAfterId, size, status, operativeStatus, tenantOrderId, startTargetTime, endTargetTime, startDate, endDate, facilityRefs, countries, facilityCountries, brandRefs, serviceLevels, serviceTypes, orderDomainStatus, routingDomainStatus, pickingDomainStatus, packingDomainStatus, shippingDomainStatus, handoverDomainStatus, returnDomainStatus, stickers, searchTerm, sortBy, sortByDirection, locked, orderStatus, {})).resolves.toBe(null)
  })
  test("getProcessByID", () => {
    const processId: string = "processId_example"
    return expect(instance.getProcessByID(processId, {})).resolves.toBe(null)
  })
  test("getProcesses", () => {
    const tenantOrderId: string = "tenantOrderId_example"
    const orderRef: string = "orderRef_example"
    const pickJobRef: string = "pickJobRef_example"
    const shipmentRef: string = "shipmentRef_example"
    const handoverJobRef: string = "handoverJobRef_example"
    const returnRef: string = "returnRef_example"
    return expect(instance.getProcesses(tenantOrderId, orderRef, pickJobRef, shipmentRef, handoverJobRef, returnRef, {})).resolves.toBe(null)
  })
  test("patchProcess", () => {
    const body: api.ProcessPatchActions = undefined
    const processId: string = "processId_example"
    return expect(instance.patchProcess(body, processId, {})).resolves.toBe(null)
  })
  test("postProcess", () => {
    const processId: string = "processId_example"
    const version: number = 1.2
    const rerouteDescriptionId: string = "rerouteDescriptionId_example"
    return expect(instance.postProcess(processId, version, rerouteDescriptionId, {})).resolves.toBe(null)
  })
  test("readDocumentMetaInProcess", () => {
    const processId: string = "processId_example"
    const documentId: string = "documentId_example"
    return expect(instance.readDocumentMetaInProcess(processId, documentId, {})).resolves.toBe(null)
  })
  test("triggerRetryNotRoutable", () => {
    return expect(instance.triggerRetryNotRoutable({})).resolves.toBe(null)
  })
  test("updateDocumentInProcess", () => {
    const body: api.ExternalDocumentForUpdate = undefined
    const processId: string = "processId_example"
    const documentId: string = "documentId_example"
    return expect(instance.updateDocumentInProcess(body, processId, documentId, {})).resolves.toBe(null)
  })
})

describe("CoreProcessesExternalActionsApi", () => {
  let instance: api.CoreProcessesExternalActionsApi
  beforeEach(function() {
    instance = new api.CoreProcessesExternalActionsApi(config)
  });

  test("deleteExternalAction", () => {
    const externalActionId: string = "externalActionId_example"
    return expect(instance.deleteExternalAction(externalActionId, {})).resolves.toBe(null)
  })
  test("getExternalAction", () => {
    const externalActionId: string = "externalActionId_example"
    return expect(instance.getExternalAction(externalActionId, {})).resolves.toBe(null)
  })
  test("getExternalActions", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const groups: Array<string> = undefined
    const processRef: string = "processRef_example"
    return expect(instance.getExternalActions(startAfterId, size, groups, processRef, {})).resolves.toBe(null)
  })
  test("postExternalAction", () => {
    const body: api.ExternalActionForCreation = undefined
    return expect(instance.postExternalAction(body, {})).resolves.toBe(null)
  })
  test("putExternalAction", () => {
    const body: api.ExternalActionForReplacement = undefined
    const externalActionId: string = "externalActionId_example"
    return expect(instance.putExternalAction(body, externalActionId, {})).resolves.toBe(null)
  })
})

describe("CoreProcessesExternalActionsLogsApi", () => {
  let instance: api.CoreProcessesExternalActionsLogsApi
  beforeEach(function() {
    instance = new api.CoreProcessesExternalActionsLogsApi(config)
  });

  test("getExternalActionLogs", () => {
    const externalActionId: string = "externalActionId_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getExternalActionLogs(externalActionId, startAfterId, size, {})).resolves.toBe(null)
  })
  test("postExternalActionLog", () => {
    const body: api.ExternalActionLogForCreation = undefined
    const externalActionId: string = "externalActionId_example"
    return expect(instance.postExternalActionLog(body, externalActionId, {})).resolves.toBe(null)
  })
})

describe("CoreRemoteConfigurationApi", () => {
  let instance: api.CoreRemoteConfigurationApi
  beforeEach(function() {
    instance = new api.CoreRemoteConfigurationApi(config)
  });

  test("addRemoteConfigurationScope", () => {
    const id: string = "id_example"
    const body: api.AddRemoteConfigurationScopeParameter = undefined
    return expect(instance.addRemoteConfigurationScope(id, body, {})).resolves.toBe(null)
  })
  test("createRemoteConfiguration", () => {
    const body: api.RemoteConfigurationForCreation = undefined
    return expect(instance.createRemoteConfiguration(body, {})).resolves.toBe(null)
  })
  test("deleteRemoteConfiguration", () => {
    const id: string = "id_example"
    return expect(instance.deleteRemoteConfiguration(id, {})).resolves.toBe(null)
  })
  test("deleteScopeFromRemoteConfiguration", () => {
    const id: string = "id_example"
    const scopeId: string = "scopeId_example"
    return expect(instance.deleteScopeFromRemoteConfiguration(id, scopeId, {})).resolves.toBe(null)
  })
  test("getAllRemoteConfigurations", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const facilityId: string = "facilityId_example"
    const groups: Array<string> = undefined
    const userId: string = "userId_example"
    return expect(instance.getAllRemoteConfigurations(startAfterId, size, facilityId, groups, userId, {})).resolves.toBe(null)
  })
  test("getRemoteConfiguration", () => {
    const id: string = "id_example"
    return expect(instance.getRemoteConfiguration(id, {})).resolves.toBe(null)
  })
  test("putRemoteConfiguration", () => {
    const id: string = "id_example"
    const body: api.RemoteConfigurationForPut = undefined
    return expect(instance.putRemoteConfiguration(id, body, {})).resolves.toBe(null)
  })
  test("updateRemoteConfiguration", () => {
    const id: string = "id_example"
    const body: api.RemoteConfigurationForUpdate = undefined
    return expect(instance.updateRemoteConfiguration(id, body, {})).resolves.toBe(null)
  })
})

describe("CoreTagsApi", () => {
  let instance: api.CoreTagsApi
  beforeEach(function() {
    instance = new api.CoreTagsApi(config)
  });

  test("addTag", () => {
    const body: api.TagForCreation = undefined
    return expect(instance.addTag(body, {})).resolves.toBe(null)
  })
  test("getTag", () => {
    const tagRef: string = "tagRef_example"
    return expect(instance.getTag(tagRef, {})).resolves.toBe(null)
  })
  test("getTags", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getTags(startAfterId, size, {})).resolves.toBe(null)
  })
  test("putTag", () => {
    const body: api.TagPatchActions = undefined
    const tagRef: string = "tagRef_example"
    return expect(instance.putTag(body, tagRef, {})).resolves.toBe(null)
  })
})

describe("CoreUserManagementApi", () => {
  let instance: api.CoreUserManagementApi
  beforeEach(function() {
    instance = new api.CoreUserManagementApi(config)
  });

  test("createUser", () => {
    const body: api.UserForCreation = undefined
    return expect(instance.createUser(body, {})).resolves.toBe(null)
  })
  test("deleteAssignedFacilities", () => {
    const userId: string = "userId_example"
    const assignedFacilityId: string = "assignedFacilityId_example"
    return expect(instance.deleteAssignedFacilities(userId, assignedFacilityId, {})).resolves.toBe(null)
  })
  test("deleteUser", () => {
    const userId: string = "userId_example"
    return expect(instance.deleteUser(userId, {})).resolves.toBe(null)
  })
  test("getAllUsers", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const orderBy: UserOrderBy = undefined
    const facilityId: string = "facilityId_example"
    const includeAdminUsers: boolean = true
    return expect(instance.getAllUsers(startAfterId, size, orderBy, facilityId, includeAdminUsers, {})).resolves.toBe(null)
  })
  test("getUser", () => {
    const userId: string = "userId_example"
    return expect(instance.getUser(userId, {})).resolves.toBe(null)
  })
  test("getUserRoles", () => {
    const userId: string = "userId_example"
    return expect(instance.getUserRoles(userId, {})).resolves.toBe(null)
  })
  test("patchUser", () => {
    const body: api.UserPatchActions = undefined
    const userId: string = "userId_example"
    return expect(instance.patchUser(body, userId, {})).resolves.toBe(null)
  })
  test("postAssignedFacilities", () => {
    const body: api.UserAssignedFacilityForCreation = undefined
    const userId: string = "userId_example"
    return expect(instance.postAssignedFacilities(body, userId, {})).resolves.toBe(null)
  })
  test("putBranding", () => {
    const body: api.Branding = undefined
    const clientName: string = "clientName_example"
    return expect(instance.putBranding(body, clientName, {})).resolves.toBe(null)
  })
  test("signTransloaditRequest", () => {
    const templateId: string = "templateId_example"
    return expect(instance.signTransloaditRequest(templateId, {})).resolves.toBe(null)
  })
})

describe("CoreValidationsApi", () => {
  let instance: api.CoreValidationsApi
  beforeEach(function() {
    instance = new api.CoreValidationsApi(config)
  });

  test("validatePostalCode", () => {
    const body: api.PostalCodeValidation = undefined
    return expect(instance.validatePostalCode(body, {})).resolves.toBe(null)
  })
})

describe("DOMSCancelationReasonsApi", () => {
  let instance: api.DOMSCancelationReasonsApi
  beforeEach(function() {
    instance = new api.DOMSCancelationReasonsApi(config)
  });

  test("deleteCancelationReason", () => {
    const cancelationReasonId: string = "cancelationReasonId_example"
    return expect(instance.deleteCancelationReason(cancelationReasonId, {})).resolves.toBe(null)
  })
  test("getCancelationReasonById", () => {
    const cancelationReasonId: string = "cancelationReasonId_example"
    return expect(instance.getCancelationReasonById(cancelationReasonId, {})).resolves.toBe(null)
  })
  test("getCancelationReasons", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getCancelationReasons(startAfterId, size, {})).resolves.toBe(null)
  })
  test("postCancelationReason", () => {
    const body: api.CancelationReasonForCreation = undefined
    return expect(instance.postCancelationReason(body, {})).resolves.toBe(null)
  })
  test("putCancelationReason", () => {
    const cancelationReasonId: string = "cancelationReasonId_example"
    const body: api.CancelationReasonForModification = undefined
    return expect(instance.putCancelationReason(cancelationReasonId, body, {})).resolves.toBe(null)
  })
})

describe("DOMSCheckoutOptionsApi", () => {
  let instance: api.DOMSCheckoutOptionsApi
  beforeEach(function() {
    instance = new api.DOMSCheckoutOptionsApi(config)
  });

  test("checkoutOptionsTimepoint", () => {
    const body: api.CheckoutOptionsDeliveryTimePointRequest = undefined
    return expect(instance.checkoutOptionsTimepoint(body, {})).resolves.toBe(null)
  })
  test("checkoutoptionDeliveryEarliest", () => {
    const body: api.CheckoutOptionsDeliveryEarliestRequest = undefined
    return expect(instance.checkoutoptionDeliveryEarliest(body, {})).resolves.toBe(null)
  })
  test("checkoutoptionDeliveryTimePeriod", () => {
    const body: api.CheckoutOptionsDeliveryTimePeriodRequest = undefined
    return expect(instance.checkoutoptionDeliveryTimePeriod(body, {})).resolves.toBe(null)
  })
  test("queryFulfillability", () => {
    const body: api.FulfillabilityQuery = undefined
    return expect(instance.queryFulfillability(body, {})).resolves.toBe(null)
  })
  test("queryFulfillabilityClickAndCollect", () => {
    const body: api.FulfillabilityClickAndCollectQuery = undefined
    return expect(instance.queryFulfillabilityClickAndCollect(body, {})).resolves.toBe(null)
  })
  test("queryFulfillabilityShipFromStore", () => {
    const body: api.FulfillabilityShipFromStoreQuery = undefined
    return expect(instance.queryFulfillabilityShipFromStore(body, {})).resolves.toBe(null)
  })
})

describe("DOMSOrdersApi", () => {
  let instance: api.DOMSOrdersApi
  beforeEach(function() {
    instance = new api.DOMSOrdersApi(config)
  });

  test("addOrder", () => {
    const body: api.OrderForCreation = undefined
    return expect(instance.addOrder(body, {})).resolves.toBe(null)
  })
  test("cancelOrder", () => {
    const orderId: string = "orderId_example"
    const body: api.OrderIdCancelBody = undefined
    return expect(instance.cancelOrder(orderId, body, {})).resolves.toBe(null)
  })
  test("getAllOrders", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const tenantOrderId: string = "tenantOrderId_example"
    return expect(instance.getAllOrders(startAfterId, size, tenantOrderId, {})).resolves.toBe(null)
  })
  test("getOrder", () => {
    const orderId: string = "orderId_example"
    return expect(instance.getOrder(orderId, {})).resolves.toBe(null)
  })
  test("getOrderTagConfiguration", () => {
    return expect(instance.getOrderTagConfiguration({})).resolves.toBe(null)
  })
  test("getPromisesConfiguration", () => {
    return expect(instance.getPromisesConfiguration({})).resolves.toBe(null)
  })
  test("orderAction", () => {
    const orderId: string = "orderId_example"
    const body: api.OrderActionsParameter = undefined
    return expect(instance.orderAction(orderId, body, {})).resolves.toBe(null)
  })
  test("postCheckoutOptions", () => {
    const body: api.CheckoutOptionsInput = undefined
    return expect(instance.postCheckoutOptions(body, {})).resolves.toBe(null)
  })
  test("postDeliveryPromise", () => {
    const body: api.OrderForCreation = undefined
    return expect(instance.postDeliveryPromise(body, {})).resolves.toBe(null)
  })
  test("putOrderTagConfigurations", () => {
    const body: api.OrderTagConfiguration = undefined
    return expect(instance.putOrderTagConfigurations(body, {})).resolves.toBe(null)
  })
  test("putPromisesConfiguration", () => {
    const body: api.PromisesConfiguration = undefined
    return expect(instance.putPromisesConfiguration(body, {})).resolves.toBe(null)
  })
})

describe("DOMSRoutingPlansApi", () => {
  let instance: api.DOMSRoutingPlansApi
  beforeEach(function() {
    instance = new api.DOMSRoutingPlansApi(config)
  });

  test("deleteRerouteDescription", () => {
    const rerouteDescriptionId: string = "rerouteDescriptionId_example"
    return expect(instance.deleteRerouteDescription(rerouteDescriptionId, {})).resolves.toBe(null)
  })
  test("deleteToolkitFence", () => {
    const toolkitFenceId: string = "toolkitFenceId_example"
    return expect(instance.deleteToolkitFence(toolkitFenceId, {})).resolves.toBe(null)
  })
  test("deleteToolkitRating", () => {
    const toolkitRatingId: string = "toolkitRatingId_example"
    return expect(instance.deleteToolkitRating(toolkitRatingId, {})).resolves.toBe(null)
  })
  test("getCapacityPlanningTimeframeConfiguration", () => {
    return expect(instance.getCapacityPlanningTimeframeConfiguration({})).resolves.toBe(null)
  })
  test("getDecisionlog", () => {
    const routingplanId: string = "routingplanId_example"
    const routingRun: number = 56
    return expect(instance.getDecisionlog(routingplanId, routingRun, {})).resolves.toBe(null)
  })
  test("getManualRerouteConfiguration", () => {
    return expect(instance.getManualRerouteConfiguration({})).resolves.toBe(null)
  })
  test("getOrderRoutingConfiguration", () => {
    return expect(instance.getOrderRoutingConfiguration({})).resolves.toBe(null)
  })
  test("getRerouteDescriptionById", () => {
    const rerouteDescriptionId: string = "rerouteDescriptionId_example"
    return expect(instance.getRerouteDescriptionById(rerouteDescriptionId, {})).resolves.toBe(null)
  })
  test("getRerouteDescriptions", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getRerouteDescriptions(startAfterId, size, {})).resolves.toBe(null)
  })
  test("getRerouteShortPickConfiguration", () => {
    return expect(instance.getRerouteShortPickConfiguration({})).resolves.toBe(null)
  })
  test("getRerouteTimeTriggeredConfiguration", () => {
    return expect(instance.getRerouteTimeTriggeredConfiguration({})).resolves.toBe(null)
  })
  test("getRoutingConfiguration", () => {
    const version: number = 1.2
    const locale: string = "locale_example"
    return expect(instance.getRoutingConfiguration(version, locale, {})).resolves.toBe(null)
  })
  test("getRoutingPlan", () => {
    const routingplanId: string = "routingplanId_example"
    return expect(instance.getRoutingPlan(routingplanId, {})).resolves.toBe(null)
  })
  test("getRoutingPlanBaseOnOrderRef", () => {
    const orderRef: string = "orderRef_example"
    return expect(instance.getRoutingPlanBaseOnOrderRef(orderRef, {})).resolves.toBe(null)
  })
  test("getToolkitFenceById", () => {
    const toolkitFenceId: string = "toolkitFenceId_example"
    return expect(instance.getToolkitFenceById(toolkitFenceId, {})).resolves.toBe(null)
  })
  test("getToolkitFences", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getToolkitFences(startAfterId, size, {})).resolves.toBe(null)
  })
  test("getToolkitRatingById", () => {
    const toolkitRatingId: string = "toolkitRatingId_example"
    return expect(instance.getToolkitRatingById(toolkitRatingId, {})).resolves.toBe(null)
  })
  test("getToolkitRatings", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getToolkitRatings(startAfterId, size, {})).resolves.toBe(null)
  })
  test("patchRoutingConfig", () => {
    const body: api.RoutingConfigurationsPatchActions = undefined
    return expect(instance.patchRoutingConfig(body, {})).resolves.toBe(null)
  })
  test("patchRoutingPlan", () => {
    const body: api.RoutingPlanPatchActions = undefined
    const routingplanId: string = "routingplanId_example"
    return expect(instance.patchRoutingPlan(body, routingplanId, {})).resolves.toBe(null)
  })
  test("postRerouteDescription", () => {
    const body: api.RerouteDescriptionForCreation = undefined
    return expect(instance.postRerouteDescription(body, {})).resolves.toBe(null)
  })
  test("postToolkitFence", () => {
    const body: api.ToolkitFenceForCreation = undefined
    return expect(instance.postToolkitFence(body, {})).resolves.toBe(null)
  })
  test("postToolkitRating", () => {
    const body: api.ToolkitRatingForCreation = undefined
    return expect(instance.postToolkitRating(body, {})).resolves.toBe(null)
  })
  test("putCapacityPlanningTimeframeConfiguration", () => {
    const body: api.CapacityPlanningTimeframeConfiguration = undefined
    return expect(instance.putCapacityPlanningTimeframeConfiguration(body, {})).resolves.toBe(null)
  })
  test("putManualRerouteConfiguration", () => {
    const body: api.ManualRerouteConfiguration = undefined
    return expect(instance.putManualRerouteConfiguration(body, {})).resolves.toBe(null)
  })
  test("putOrderRoutingConfiguration", () => {
    const body: api.OrderRoutingConfiguration = undefined
    return expect(instance.putOrderRoutingConfiguration(body, {})).resolves.toBe(null)
  })
  test("putRerouteDescription", () => {
    const rerouteDescriptionId: string = "rerouteDescriptionId_example"
    const body: api.RerouteDescriptionForModification = undefined
    return expect(instance.putRerouteDescription(rerouteDescriptionId, body, {})).resolves.toBe(null)
  })
  test("putRerouteShortPickConfiguration", () => {
    const body: api.RerouteShortPickConfiguration = undefined
    return expect(instance.putRerouteShortPickConfiguration(body, {})).resolves.toBe(null)
  })
  test("putRerouteTimeTriggeredConfiguration", () => {
    const body: api.RerouteTimeTriggeredConfiguration = undefined
    return expect(instance.putRerouteTimeTriggeredConfiguration(body, {})).resolves.toBe(null)
  })
  test("putRoutingConfiguration", () => {
    const body: api.RoutingConfiguration = undefined
    return expect(instance.putRoutingConfiguration(body, {})).resolves.toBe(null)
  })
  test("putToolkitFence", () => {
    const toolkitFenceId: string = "toolkitFenceId_example"
    const body: api.ToolkitFenceForModification = undefined
    return expect(instance.putToolkitFence(toolkitFenceId, body, {})).resolves.toBe(null)
  })
  test("putToolkitRating", () => {
    const toolkitRatingId: string = "toolkitRatingId_example"
    const body: api.ToolkitRatingForModification = undefined
    return expect(instance.putToolkitRating(toolkitRatingId, body, {})).resolves.toBe(null)
  })
  test("reRoute", () => {
    const body: api.RerouteRoutingPlan = undefined
    return expect(instance.reRoute(body, {})).resolves.toBe(null)
  })
})

describe("FulfillmentOperationsCustomServicesApi", () => {
  let instance: api.FulfillmentOperationsCustomServicesApi
  beforeEach(function() {
    instance = new api.FulfillmentOperationsCustomServicesApi(config)
  });

  test("addNestedServiceJobLink", () => {
    const body: api.ServiceJobLinkForAdding = undefined
    const linkedServiceJobsId: string = "linkedServiceJobsId_example"
    const serviceJobLinkId: string = "serviceJobLinkId_example"
    return expect(instance.addNestedServiceJobLink(body, linkedServiceJobsId, serviceJobLinkId, {})).resolves.toBe(null)
  })
  test("addServiceJobLink", () => {
    const body: api.ServiceJobLinkForAdding = undefined
    const linkedServiceJobsId: string = "linkedServiceJobsId_example"
    return expect(instance.addServiceJobLink(body, linkedServiceJobsId, {})).resolves.toBe(null)
  })
  test("createServiceJob", () => {
    const body: api.ServiceJobForCreation = undefined
    return expect(instance.createServiceJob(body, {})).resolves.toBe(null)
  })
  test("getLinkedServiceJobs", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const facilityIds: Array<string> = undefined
    const status: Array<string> = undefined
    const orderBy: LinkedServiceJobsOrderBy = undefined
    const channel: LinkedServiceJobsFilterChannel = undefined
    const startTargetTime: Date = 2013-10-20T19:20:30+01:00
    const endTargetTime: Date = 2013-10-20T19:20:30+01:00
    const searchTerm: string = "searchTerm_example"
    return expect(instance.getLinkedServiceJobs(startAfterId, size, facilityIds, status, orderBy, channel, startTargetTime, endTargetTime, searchTerm, {})).resolves.toBe(null)
  })
  test("getLinkedServiceJobsById", () => {
    const linkedServiceJobsId: string = "linkedServiceJobsId_example"
    return expect(instance.getLinkedServiceJobsById(linkedServiceJobsId, {})).resolves.toBe(null)
  })
  test("getServiceJob", () => {
    const serviceJobId: string = "serviceJobId_example"
    return expect(instance.getServiceJob(serviceJobId, {})).resolves.toBe(null)
  })
  test("getServiceJobs", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const facilityRef: string = "facilityRef_example"
    const status: Array<string> = undefined
    const channel: ServiceJobFilterChannel = undefined
    const startTargetTime: Date = 2013-10-20T19:20:30+01:00
    const endTargetTime: Date = 2013-10-20T19:20:30+01:00
    const searchTerm: string = "searchTerm_example"
    return expect(instance.getServiceJobs(startAfterId, size, facilityRef, status, channel, startTargetTime, endTargetTime, searchTerm, {})).resolves.toBe(null)
  })
  test("updateServiceJob", () => {
    const body: api.ServiceJobActionsParameter = undefined
    const serviceJobId: string = "serviceJobId_example"
    return expect(instance.updateServiceJob(body, serviceJobId, {})).resolves.toBe(null)
  })
})

describe("FulfillmentOperationsHandoverApi", () => {
  let instance: api.FulfillmentOperationsHandoverApi
  beforeEach(function() {
    instance = new api.FulfillmentOperationsHandoverApi(config)
  });

  test("addHandoverjob", () => {
    const body: api.HandoverjobForCreation = undefined
    return expect(instance.addHandoverjob(body, {})).resolves.toBe(null)
  })
  test("getAllHandoverjobs", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const pickJobRef: string = "pickJobRef_example"
    const shipmentRef: string = "shipmentRef_example"
    const facilityRef: string = "facilityRef_example"
    const status: Array<string> = undefined
    const carrierRefs: Array<string> = undefined
    const channel: string = "channel_example"
    const anonymized: boolean = true
    const searchTerm: string = "searchTerm_example"
    const startTargetTime: Date = 2013-10-20T19:20:30+01:00
    const endTargetTime: Date = 2013-10-20T19:20:30+01:00
    return expect(instance.getAllHandoverjobs(startAfterId, size, pickJobRef, shipmentRef, facilityRef, status, carrierRefs, channel, anonymized, searchTerm, startTargetTime, endTargetTime, {})).resolves.toBe(null)
  })
  test("getAllRefuseReasons", () => {
    return expect(instance.getAllRefuseReasons({})).resolves.toBe(null)
  })
  test("getHandoverConfiguration", () => {
    return expect(instance.getHandoverConfiguration({})).resolves.toBe(null)
  })
  test("getHandoverJobTagConfiguration", () => {
    return expect(instance.getHandoverJobTagConfiguration({})).resolves.toBe(null)
  })
  test("getHandoverjob", () => {
    const handoverjobId: string = "handoverjobId_example"
    return expect(instance.getHandoverjob(handoverjobId, {})).resolves.toBe(null)
  })
  test("handoverJobAction", () => {
    const handoverJobId: string = "handoverJobId_example"
    const body: api.HandoverJobActionsParameter = undefined
    return expect(instance.handoverJobAction(handoverJobId, body, {})).resolves.toBe(null)
  })
  test("patchHandoverjob", () => {
    const body: api.HandoverjobPatchActions = undefined
    const handoverjobId: string = "handoverjobId_example"
    return expect(instance.patchHandoverjob(body, handoverjobId, {})).resolves.toBe(null)
  })
  test("putHandoverTagConfigurations", () => {
    const body: api.HandoverJobTagConfiguration = undefined
    return expect(instance.putHandoverTagConfigurations(body, {})).resolves.toBe(null)
  })
  test("upsertHandoverConfiguration", () => {
    const body: api.HandoverConfigurationForCreate = undefined
    return expect(instance.upsertHandoverConfiguration(body, {})).resolves.toBe(null)
  })
})

describe("FulfillmentOperationsOperativeProcessApi", () => {
  let instance: api.FulfillmentOperationsOperativeProcessApi
  beforeEach(function() {
    instance = new api.FulfillmentOperationsOperativeProcessApi(config)
  });

  test("getOperativeProcessById", () => {
    const operativeProcessId: string = "operativeProcessId_example"
    return expect(instance.getOperativeProcessById(operativeProcessId, {})).resolves.toBe(null)
  })
  test("getOperativeProcesses", () => {
    const facilityId: string = "facilityId_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getOperativeProcesses(facilityId, startAfterId, size, {})).resolves.toBe(null)
  })
})

describe("FulfillmentOperationsPackingApi", () => {
  let instance: api.FulfillmentOperationsPackingApi
  beforeEach(function() {
    instance = new api.FulfillmentOperationsPackingApi(config)
  });

  test("addPackJob", () => {
    const body: api.PackJobForCreation = undefined
    return expect(instance.addPackJob(body, {})).resolves.toBe(null)
  })
  test("addPackingContainerType", () => {
    const body: api.PackingContainerTypeForCreation = undefined
    return expect(instance.addPackingContainerType(body, {})).resolves.toBe(null)
  })
  test("addPackingSourceContainer", () => {
    const body: api.PackingSourceContainerForCreation = undefined
    return expect(instance.addPackingSourceContainer(body, {})).resolves.toBe(null)
  })
  test("addTargetContainers", () => {
    const body: api.PackingTargetContainerForCreation = undefined
    const packJobId: string = "packJobId_example"
    return expect(instance.addTargetContainers(body, packJobId, {})).resolves.toBe(null)
  })
  test("addTargetcontainer", () => {
    const body: api.PackingTargetContainerLineItemForCreation = undefined
    const packJobId: string = "packJobId_example"
    const targetcontainerId: string = "targetcontainerId_example"
    return expect(instance.addTargetcontainer(body, packJobId, targetcontainerId, {})).resolves.toBe(null)
  })
  test("deleteLineItemTargetContainers", () => {
    const packJobId: string = "packJobId_example"
    const targetcontainerId: string = "targetcontainerId_example"
    const lineItemId: string = "lineItemId_example"
    return expect(instance.deleteLineItemTargetContainers(packJobId, targetcontainerId, lineItemId, {})).resolves.toBe(null)
  })
  test("deletePackingTargetContainer", () => {
    const packJobId: string = "packJobId_example"
    const targetcontainerId: string = "targetcontainerId_example"
    return expect(instance.deletePackingTargetContainer(packJobId, targetcontainerId, {})).resolves.toBe(null)
  })
  test("getAllTargetcontainers", () => {
    const packJobId: string = "packJobId_example"
    return expect(instance.getAllTargetcontainers(packJobId, {})).resolves.toBe(null)
  })
  test("getNeedsPacking", () => {
    const body: Array<api.TagReference> = undefined
    return expect(instance.getNeedsPacking(body, {})).resolves.toBe(null)
  })
  test("getPackJob", () => {
    const packJobId: string = "packJobId_example"
    return expect(instance.getPackJob(packJobId, {})).resolves.toBe(null)
  })
  test("getPackJobDeliveryNote", () => {
    const packJobId: string = "packJobId_example"
    const locale: string = "locale_example"
    return expect(instance.getPackJobDeliveryNote(packJobId, locale, {})).resolves.toBe(null)
  })
  test("getPackJobDocumentHandling", () => {
    const packJobId: string = "packJobId_example"
    return expect(instance.getPackJobDocumentHandling(packJobId, {})).resolves.toBe(null)
  })
  test("getPackJobTagConfiguration", () => {
    return expect(instance.getPackJobTagConfiguration({})).resolves.toBe(null)
  })
  test("getPackJobs", () => {
    const size: number = 56
    const startAfterId: string = "startAfterId_example"
    const anonymized: boolean = true
    const status: Array<string> = undefined
    const facilityRef: string = "facilityRef_example"
    const searchTerm: string = "searchTerm_example"
    const channel: string = "channel_example"
    const sourceContainerCodes: Array<string> = undefined
    const orderBy: string = "orderBy_example"
    const startTargetTime: Date = 2013-10-20T19:20:30+01:00
    const endTargetTime: Date = 2013-10-20T19:20:30+01:00
    return expect(instance.getPackJobs(size, startAfterId, anonymized, status, facilityRef, searchTerm, channel, sourceContainerCodes, orderBy, startTargetTime, endTargetTime, {})).resolves.toBe(null)
  })
  test("getPackingConfigurations", () => {
    return expect(instance.getPackingConfigurations({})).resolves.toBe(null)
  })
  test("getPackingContainerRequirement", () => {
    return expect(instance.getPackingContainerRequirement({})).resolves.toBe(null)
  })
  test("getPackingContainerType", () => {
    const packingContainerTypeId: string = "packingContainerTypeId_example"
    const locale: string = "locale_example"
    return expect(instance.getPackingContainerType(packingContainerTypeId, locale, {})).resolves.toBe(null)
  })
  test("getPackingContainerTypes", () => {
    const locale: string = "locale_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getPackingContainerTypes(locale, startAfterId, size, {})).resolves.toBe(null)
  })
  test("getPackingSourceContainerById", () => {
    const packingSourceContainerId: string = "packingSourceContainerId_example"
    const locale: string = "locale_example"
    return expect(instance.getPackingSourceContainerById(packingSourceContainerId, locale, {})).resolves.toBe(null)
  })
  test("getPackingSourceContainers", () => {
    const facilityRef: string = "facilityRef_example"
    const locale: string = "locale_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const packJobRef: string = "packJobRef_example"
    const codes: Array<string> = undefined
    return expect(instance.getPackingSourceContainers(facilityRef, locale, startAfterId, size, packJobRef, codes, {})).resolves.toBe(null)
  })
  test("getReturnNotesForPackJob", () => {
    const packJobId: string = "packJobId_example"
    const locale: string = "locale_example"
    return expect(instance.getReturnNotesForPackJob(packJobId, locale, {})).resolves.toBe(null)
  })
  test("getTargetcontainer", () => {
    const packJobId: string = "packJobId_example"
    const targetcontainerId: string = "targetcontainerId_example"
    const locale: string = "locale_example"
    return expect(instance.getTargetcontainer(packJobId, targetcontainerId, locale, {})).resolves.toBe(null)
  })
  test("patchPackJob", () => {
    const body: api.PackJobPatchActions = undefined
    const packJobId: string = "packJobId_example"
    return expect(instance.patchPackJob(body, packJobId, {})).resolves.toBe(null)
  })
  test("patchTargetContainerLineItem", () => {
    const body: api.PackingTargetContainerActionsParameter = undefined
    const packJobId: string = "packJobId_example"
    const targetcontainerId: string = "targetcontainerId_example"
    const lineItemId: string = "lineItemId_example"
    return expect(instance.patchTargetContainerLineItem(body, packJobId, targetcontainerId, lineItemId, {})).resolves.toBe(null)
  })
  test("patchTargetcontainer", () => {
    const body: api.PackingTargetContainerPatchActions = undefined
    const packJobId: string = "packJobId_example"
    const targetcontainerId: string = "targetcontainerId_example"
    return expect(instance.patchTargetcontainer(body, packJobId, targetcontainerId, {})).resolves.toBe(null)
  })
  test("putPackJobTagConfiguration", () => {
    const body: api.PackJobTagConfiguration = undefined
    return expect(instance.putPackJobTagConfiguration(body, {})).resolves.toBe(null)
  })
  test("putPackingContainerRequirement", () => {
    const body: api.PackingContainerRequiredConfiguration = undefined
    return expect(instance.putPackingContainerRequirement(body, {})).resolves.toBe(null)
  })
  test("updatePackingContainerType", () => {
    const body: api.PackingContainerTypePatchActions = undefined
    const packingContainerTypeId: string = "packingContainerTypeId_example"
    return expect(instance.updatePackingContainerType(body, packingContainerTypeId, {})).resolves.toBe(null)
  })
  test("upsertPackingConfigurations", () => {
    const body: api.PackingConfigurations = undefined
    return expect(instance.upsertPackingConfigurations(body, {})).resolves.toBe(null)
  })
})

describe("FulfillmentOperationsPickingApi", () => {
  let instance: api.FulfillmentOperationsPickingApi
  beforeEach(function() {
    instance = new api.FulfillmentOperationsPickingApi(config)
  });

  test("addLoadUnit", () => {
    const body: api.LoadUnitsForCreation = undefined
    return expect(instance.addLoadUnit(body, {})).resolves.toBe(null)
  })
  test("addPickJob", () => {
    const body: api.PickJobForCreation = undefined
    return expect(instance.addPickJob(body, {})).resolves.toBe(null)
  })
  test("addPickJobLoadUnits", () => {
    const body: api.PickingLoadUnitForCreation = undefined
    const pickJobId: string = "pickJobId_example"
    return expect(instance.addPickJobLoadUnits(body, pickJobId, {})).resolves.toBe(null)
  })
  test("addPickRun", () => {
    const body: api.PickRunForCreation = undefined
    return expect(instance.addPickRun(body, {})).resolves.toBe(null)
  })
  test("createLoadUnitTypes", () => {
    const body: api.LoadUnitTypeForCreation = undefined
    return expect(instance.createLoadUnitTypes(body, {})).resolves.toBe(null)
  })
  test("deleteLoadUnit", () => {
    const loadUnitId: string = "loadUnitId_example"
    return expect(instance.deleteLoadUnit(loadUnitId, {})).resolves.toBe(null)
  })
  test("deleteLoadUnits", () => {
    const pickJobRef: string = "pickJobRef_example"
    const id: Array<string> = undefined
    return expect(instance.deleteLoadUnits(pickJobRef, id, {})).resolves.toBe(null)
  })
  test("deleteSubstitutesForTenantArticleId", () => {
    const tenantArticleId: string = "tenantArticleId_example"
    return expect(instance.deleteSubstitutesForTenantArticleId(tenantArticleId, {})).resolves.toBe(null)
  })
  test("getAllLoadUnits", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const pickJobRef: string = "pickJobRef_example"
    const locale: string = "locale_example"
    return expect(instance.getAllLoadUnits(startAfterId, size, pickJobRef, locale, {})).resolves.toBe(null)
  })
  test("getCutoffTimeConfiguration", () => {
    return expect(instance.getCutoffTimeConfiguration({})).resolves.toBe(null)
  })
  test("getDefaultPickingTimesConfiguration", () => {
    return expect(instance.getDefaultPickingTimesConfiguration({})).resolves.toBe(null)
  })
  test("getFulfillmentProcessBufferConfiguration", () => {
    return expect(instance.getFulfillmentProcessBufferConfiguration({})).resolves.toBe(null)
  })
  test("getLoadUnitByID", () => {
    const loadUnitId: string = "loadUnitId_example"
    const locale: string = "locale_example"
    return expect(instance.getLoadUnitByID(loadUnitId, locale, {})).resolves.toBe(null)
  })
  test("getLoadUnitConfiguration", () => {
    return expect(instance.getLoadUnitConfiguration({})).resolves.toBe(null)
  })
  test("getLoadUnitTypeByID", () => {
    const loadUnitTypeId: string = "loadUnitTypeId_example"
    const locale: string = "locale_example"
    return expect(instance.getLoadUnitTypeByID(loadUnitTypeId, locale, {})).resolves.toBe(null)
  })
  test("getLoadUnitTypes", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const locale: string = "locale_example"
    return expect(instance.getLoadUnitTypes(startAfterId, size, locale, {})).resolves.toBe(null)
  })
  test("getPickJob", () => {
    const pickJobId: string = "pickJobId_example"
    return expect(instance.getPickJob(pickJobId, {})).resolves.toBe(null)
  })
  test("getPickJobDeliveryNote", () => {
    const pickJobId: string = "pickJobId_example"
    const locale: string = "locale_example"
    return expect(instance.getPickJobDeliveryNote(pickJobId, locale, {})).resolves.toBe(null)
  })
  test("getPickJobDocumentHandling", () => {
    const pickJobId: string = "pickJobId_example"
    return expect(instance.getPickJobDocumentHandling(pickJobId, {})).resolves.toBe(null)
  })
  test("getPickJobTagConfiguration", () => {
    return expect(instance.getPickJobTagConfiguration({})).resolves.toBe(null)
  })
  test("getPickRun", () => {
    const pickRunId: string = "pickRunId_example"
    return expect(instance.getPickRun(pickRunId, {})).resolves.toBe(null)
  })
  test("getPickingConfigurations", () => {
    return expect(instance.getPickingConfigurations({})).resolves.toBe(null)
  })
  test("getResultingSubstitutesForTenantArticleId", () => {
    const tenantArticleId: string = "tenantArticleId_example"
    return expect(instance.getResultingSubstitutesForTenantArticleId(tenantArticleId, {})).resolves.toBe(null)
  })
  test("getReturnNotesForPickjob", () => {
    const pickjobId: string = "pickjobId_example"
    return expect(instance.getReturnNotesForPickjob(pickjobId, {})).resolves.toBe(null)
  })
  test("getSubstitutesForTenantArticleId", () => {
    const tenantArticleId: string = "tenantArticleId_example"
    return expect(instance.getSubstitutesForTenantArticleId(tenantArticleId, {})).resolves.toBe(null)
  })
  test("getSubstitutionConfiguration", () => {
    return expect(instance.getSubstitutionConfiguration({})).resolves.toBe(null)
  })
  test("patchLoadUnitByID", () => {
    const body: api.LoadunitsLoadUnitIdBody = undefined
    const loadUnitId: string = "loadUnitId_example"
    const locale: string = "locale_example"
    return expect(instance.patchLoadUnitByID(body, loadUnitId, locale, {})).resolves.toBe(null)
  })
  test("patchPickJob", () => {
    const body: api.PickingPatchActions = undefined
    const pickJobId: string = "pickJobId_example"
    return expect(instance.patchPickJob(body, pickJobId, {})).resolves.toBe(null)
  })
  test("patchPickRun", () => {
    const body: api.PickRunPatchAction = undefined
    const pickRunId: string = "pickRunId_example"
    return expect(instance.patchPickRun(body, pickRunId, {})).resolves.toBe(null)
  })
  test("patchPickRunPickJobs", () => {
    const pickRunId: string = "pickRunId_example"
    const body: api.PickRunPickJobsPatchAction = undefined
    return expect(instance.patchPickRunPickJobs(pickRunId, body, {})).resolves.toBe(null)
  })
  test("pickJobAction", () => {
    const pickJobId: string = "pickJobId_example"
    const body: api.PickJobActionsParameter = undefined
    return expect(instance.pickJobAction(pickJobId, body, {})).resolves.toBe(null)
  })
  test("pickRunAction", () => {
    const pickRunId: string = "pickRunId_example"
    const body: api.PickRunActionsParameter = undefined
    return expect(instance.pickRunAction(pickRunId, body, {})).resolves.toBe(null)
  })
  test("putCutoffTimeConfiguration", () => {
    const body: api.CutoffTimeConfiguration = undefined
    return expect(instance.putCutoffTimeConfiguration(body, {})).resolves.toBe(null)
  })
  test("putDefaultPickingTimesConfiguration", () => {
    const body: api.DefaultPickingTimesConfiguration = undefined
    return expect(instance.putDefaultPickingTimesConfiguration(body, {})).resolves.toBe(null)
  })
  test("putFulfillmentProcessBufferConfiguration", () => {
    const body: api.FulfillmentProcessBufferConfiguration = undefined
    return expect(instance.putFulfillmentProcessBufferConfiguration(body, {})).resolves.toBe(null)
  })
  test("putLoadUnitConfiguration", () => {
    const body: api.LoadUnitConfiguration = undefined
    return expect(instance.putLoadUnitConfiguration(body, {})).resolves.toBe(null)
  })
  test("putPickJobTagConfigurations", () => {
    const body: api.PickJobTagConfiguration = undefined
    return expect(instance.putPickJobTagConfigurations(body, {})).resolves.toBe(null)
  })
  test("putPickingConfigurations", () => {
    const body: api.PickingConfigurations = undefined
    return expect(instance.putPickingConfigurations(body, {})).resolves.toBe(null)
  })
  test("putSubstitutesForTenantArticleID", () => {
    const body: api.SubstitutesForUpsert = undefined
    const tenantArticleId: string = "tenantArticleId_example"
    return expect(instance.putSubstitutesForTenantArticleID(body, tenantArticleId, {})).resolves.toBe(null)
  })
  test("putSubstitutionConfiguration", () => {
    const body: api.SubstitutionConfiguration = undefined
    return expect(instance.putSubstitutionConfiguration(body, {})).resolves.toBe(null)
  })
  test("queryPickJobLoadUnits", () => {
    const pickJobId: string = "pickJobId_example"
    return expect(instance.queryPickJobLoadUnits(pickJobId, {})).resolves.toBe(null)
  })
  test("queryPickJobs", () => {
    const searchTerm: string = "searchTerm_example"
    const carrierKeys: Array<string> = undefined
    const startOrderDate: string = "startOrderDate_example"
    const endOrderDate: string = "endOrderDate_example"
    const orderRef: string = "orderRef_example"
    const facilityRef: string = "facilityRef_example"
    const status: Array<string> = undefined
    const zoneRefs: Array<string> = undefined
    const tenantOrderId: string = "tenantOrderId_example"
    const channel: string = "channel_example"
    const consumerName: string = "consumerName_example"
    const shortId: string = "shortId_example"
    const articleTitle: string = "articleTitle_example"
    const anonymized: boolean = true
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const orderBy: string = "orderBy_example"
    const startTargetTime: Date = 2013-10-20T19:20:30+01:00
    const endTargetTime: Date = 2013-10-20T19:20:30+01:00
    const pickJobRefs: Array<string> = undefined
    const modifiedByUsername: string = "modifiedByUsername_example"
    return expect(instance.queryPickJobs(searchTerm, carrierKeys, startOrderDate, endOrderDate, orderRef, facilityRef, status, zoneRefs, tenantOrderId, channel, consumerName, shortId, articleTitle, anonymized, startAfterId, size, orderBy, startTargetTime, endTargetTime, pickJobRefs, modifiedByUsername, {})).resolves.toBe(null)
  })
  test("queryPickLineItemsSubstitutes", () => {
    const pickJobId: string = "pickJobId_example"
    const pickLineItemId: string = "pickLineItemId_example"
    return expect(instance.queryPickLineItemsSubstitutes(pickJobId, pickLineItemId, {})).resolves.toBe(null)
  })
  test("updateLoadUnitType", () => {
    const body: api.LoadUnitTypePatchActions = undefined
    const loadUnitTypeId: string = "loadUnitTypeId_example"
    return expect(instance.updateLoadUnitType(body, loadUnitTypeId, {})).resolves.toBe(null)
  })
  test("uploadLoadUnitTypeIcon", () => {
    const body: api.NamedFile = undefined
    const loadUnitTypeId: string = "loadUnitTypeId_example"
    return expect(instance.uploadLoadUnitTypeIcon(body, loadUnitTypeId, {})).resolves.toBe(null)
  })
})

describe("FulfillmentOperationsRestowApi", () => {
  let instance: api.FulfillmentOperationsRestowApi
  beforeEach(function() {
    instance = new api.FulfillmentOperationsRestowApi(config)
  });

  test("getRestowItem", () => {
    const restowItemId: string = "restowItemId_example"
    return expect(instance.getRestowItem(restowItemId, {})).resolves.toBe(null)
  })
  test("patchRestowItem", () => {
    const body: api.RestowItemPatchActions = undefined
    const restowItemId: string = "restowItemId_example"
    return expect(instance.patchRestowItem(body, restowItemId, {})).resolves.toBe(null)
  })
  test("queryRestowItems", () => {
    const facilityRef: string = "facilityRef_example"
    const restowed: boolean = true
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.queryRestowItems(facilityRef, restowed, startAfterId, size, {})).resolves.toBe(null)
  })
})

describe("FulfillmentOperationsReturnsApi", () => {
  let instance: api.FulfillmentOperationsReturnsApi
  beforeEach(function() {
    instance = new api.FulfillmentOperationsReturnsApi(config)
  });

  test("addReturn", () => {
    const body: api.ReturnJobForCreation = undefined
    return expect(instance.addReturn(body, {})).resolves.toBe(null)
  })
  test("createItemReturn", () => {
    const body: api.AddItemReturnToItemReturnJob = undefined
    const itemReturnJobId: string = "itemReturnJobId_example"
    return expect(instance.createItemReturn(body, itemReturnJobId, {})).resolves.toBe(null)
  })
  test("createItemReturnJob", () => {
    const body: api.ItemReturnJobForCreation = undefined
    return expect(instance.createItemReturnJob(body, {})).resolves.toBe(null)
  })
  test("deleteItemReturn", () => {
    const itemReturnJobId: string = "itemReturnJobId_example"
    const itemReturnId: string = "itemReturnId_example"
    const itemReturnJobVersion: number = 1.2
    return expect(instance.deleteItemReturn(itemReturnJobId, itemReturnId, itemReturnJobVersion, {})).resolves.toBe(null)
  })
  test("findItemReturns", () => {
    const searchTerm: string = "searchTerm_example"
    const facilityRefs: Array<string> = undefined
    const itemReturnStatus: Array<string> = undefined
    const itemReturnLineItemStatus: Array<string> = undefined
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.findItemReturns(searchTerm, facilityRefs, itemReturnStatus, itemReturnLineItemStatus, startAfterId, size, {})).resolves.toBe(null)
  })
  test("getItemReturn", () => {
    const itemReturnJobId: string = "itemReturnJobId_example"
    const itemReturnId: string = "itemReturnId_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getItemReturn(itemReturnJobId, itemReturnId, startAfterId, size, {})).resolves.toBe(null)
  })
  test("getItemReturnJob", () => {
    const itemReturnJobId: string = "itemReturnJobId_example"
    return expect(instance.getItemReturnJob(itemReturnJobId, {})).resolves.toBe(null)
  })
  test("getItemReturnJobs", () => {
    const facilityId: string = "facilityId_example"
    const itemReturnJobScannableCodes: Array<string> = undefined
    const itemReturnScannableCodes: Array<string> = undefined
    const itemReturnJobStatus: Array<string> = undefined
    const itemReturnStatus: Array<string> = undefined
    const searchTerm: string = "searchTerm_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getItemReturnJobs(facilityId, itemReturnJobScannableCodes, itemReturnScannableCodes, itemReturnJobStatus, itemReturnStatus, searchTerm, startAfterId, size, {})).resolves.toBe(null)
  })
  test("getItemReturns", () => {
    const itemReturnJobId: string = "itemReturnJobId_example"
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getItemReturns(itemReturnJobId, startAfterId, size, {})).resolves.toBe(null)
  })
  test("getReturnConfiguration", () => {
    return expect(instance.getReturnConfiguration({})).resolves.toBe(null)
  })
  test("getReturnJobs", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const facilityRef: string = "facilityRef_example"
    const status: Array<string> = undefined
    return expect(instance.getReturnJobs(startAfterId, size, facilityRef, status, {})).resolves.toBe(null)
  })
  test("getReturnLines", () => {
    const returnId: string = "returnId_example"
    return expect(instance.getReturnLines(returnId, {})).resolves.toBe(null)
  })
  test("itemReturnActions", () => {
    const itemReturnJobId: string = "itemReturnJobId_example"
    const itemReturnId: string = "itemReturnId_example"
    const body: api.ItemReturnActionsParameter = undefined
    return expect(instance.itemReturnActions(itemReturnJobId, itemReturnId, body, {})).resolves.toBe(null)
  })
  test("patchReturn", () => {
    const body: api.ReturnPatchActions = undefined
    const returnId: string = "returnId_example"
    return expect(instance.patchReturn(body, returnId, {})).resolves.toBe(null)
  })
  test("replaceReturnedLineItems", () => {
    const itemReturnJobId: string = "itemReturnJobId_example"
    const itemReturnId: string = "itemReturnId_example"
    const body: api.ReplaceReturnedLineItems = undefined
    return expect(instance.replaceReturnedLineItems(itemReturnJobId, itemReturnId, body, {})).resolves.toBe(null)
  })
  test("updateItemReturnJob", () => {
    const itemReturnJobId: string = "itemReturnJobId_example"
    const body: api.ItemReturnJobActionsParameter = undefined
    return expect(instance.updateItemReturnJob(itemReturnJobId, body, {})).resolves.toBe(null)
  })
  test("updateItemReturnLineItem", () => {
    const itemReturnJobId: string = "itemReturnJobId_example"
    const itemReturnId: string = "itemReturnId_example"
    const returnedLineItemId: string = "returnedLineItemId_example"
    const body: api.ItemReturnLineItemForUpdate = undefined
    return expect(instance.updateItemReturnLineItem(itemReturnJobId, itemReturnId, returnedLineItemId, body, {})).resolves.toBe(null)
  })
  test("upsertReturnConfiguration", () => {
    const body: api.ReturnConfiguration = undefined
    return expect(instance.upsertReturnConfiguration(body, {})).resolves.toBe(null)
  })
})

describe("FulfillmentOperationsShipmentsApi", () => {
  let instance: api.FulfillmentOperationsShipmentsApi
  beforeEach(function() {
    instance = new api.FulfillmentOperationsShipmentsApi(config)
  });

  test("addParcel", () => {
    const shipmentId: string = "shipmentId_example"
    const body: api.ParcelForCreation = undefined
    return expect(instance.addParcel(shipmentId, body, {})).resolves.toBe(null)
  })
  test("addShipment", () => {
    const body: api.ShipmentForCreation = undefined
    return expect(instance.addShipment(body, {})).resolves.toBe(null)
  })
  test("createDeliveryNote", () => {
    const body: api.DeliveryNote = undefined
    const locale: string = "locale_example"
    return expect(instance.createDeliveryNote(body, locale, {})).resolves.toBe(null)
  })
  test("createReturnNote", () => {
    const body: api.ReturnNote = undefined
    const locale: string = "locale_example"
    return expect(instance.createReturnNote(body, locale, {})).resolves.toBe(null)
  })
  test("deleteParcel", () => {
    const parcelId: string = "parcelId_example"
    return expect(instance.deleteParcel(parcelId, {})).resolves.toBe(null)
  })
  test("getAllParcels", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    return expect(instance.getAllParcels(startAfterId, size, {})).resolves.toBe(null)
  })
  test("getAllShipments", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const pickJobRef: string = "pickJobRef_example"
    const facilityRef: string = "facilityRef_example"
    const carrierRef: string = "carrierRef_example"
    const carrierKeys: Array<string> = undefined
    const status: Array<string> = undefined
    const parcelStatus: Array<string> = undefined
    const startTargetTime: Date = 2013-10-20T19:20:30+01:00
    const endTargetTime: Date = 2013-10-20T19:20:30+01:00
    const anonymized: boolean = true
    const searchTerm: string = "searchTerm_example"
    return expect(instance.getAllShipments(startAfterId, size, pickJobRef, facilityRef, carrierRef, carrierKeys, status, parcelStatus, startTargetTime, endTargetTime, anonymized, searchTerm, {})).resolves.toBe(null)
  })
  test("getDeliveryNoteConfiguration", () => {
    return expect(instance.getDeliveryNoteConfiguration({})).resolves.toBe(null)
  })
  test("getLabelForParcel", () => {
    const parcelId: string = "parcelId_example"
    const labelDocument: string = "labelDocument_example"
    return expect(instance.getLabelForParcel(parcelId, labelDocument, {})).resolves.toBe(null)
  })
  test("getParcel", () => {
    const parcelId: string = "parcelId_example"
    return expect(instance.getParcel(parcelId, {})).resolves.toBe(null)
  })
  test("getParcelDeliveryNote", () => {
    const parcelId: string = "parcelId_example"
    const locale: string = "locale_example"
    return expect(instance.getParcelDeliveryNote(parcelId, locale, {})).resolves.toBe(null)
  })
  test("getParcelReturnNote", () => {
    const parcelId: string = "parcelId_example"
    const locale: string = "locale_example"
    return expect(instance.getParcelReturnNote(parcelId, locale, {})).resolves.toBe(null)
  })
  test("getParcelTagConfiguration", () => {
    return expect(instance.getParcelTagConfiguration({})).resolves.toBe(null)
  })
  test("getReturnNoteConfiguration", () => {
    return expect(instance.getReturnNoteConfiguration({})).resolves.toBe(null)
  })
  test("getShipment", () => {
    const shipmentId: string = "shipmentId_example"
    return expect(instance.getShipment(shipmentId, {})).resolves.toBe(null)
  })
  test("getShipmentDeliveryNote", () => {
    const shipmentId: string = "shipmentId_example"
    const locale: string = "locale_example"
    return expect(instance.getShipmentDeliveryNote(shipmentId, locale, {})).resolves.toBe(null)
  })
  test("patchParcel", () => {
    const body: api.ParcelPatchActions = undefined
    const parcelId: string = "parcelId_example"
    return expect(instance.patchParcel(body, parcelId, {})).resolves.toBe(null)
  })
  test("patchShipment", () => {
    const body: api.ShipmentPatchActions = undefined
    const shipmentId: string = "shipmentId_example"
    return expect(instance.patchShipment(body, shipmentId, {})).resolves.toBe(null)
  })
  test("putDeliveryNoteConfiguration", () => {
    const body: api.DeliveryNoteConfigurationForUpsert = undefined
    return expect(instance.putDeliveryNoteConfiguration(body, {})).resolves.toBe(null)
  })
  test("putParcelTagConfiguration", () => {
    const body: api.ParcelTagConfigurationForUpsert = undefined
    return expect(instance.putParcelTagConfiguration(body, {})).resolves.toBe(null)
  })
  test("putReturnNoteConfiguration", () => {
    const body: api.ReturnNoteConfigurationForUpsert = undefined
    return expect(instance.putReturnNoteConfiguration(body, {})).resolves.toBe(null)
  })
})

describe("InfrastructureArtifactsApi", () => {
  let instance: api.InfrastructureArtifactsApi
  beforeEach(function() {
    instance = new api.InfrastructureArtifactsApi(config)
  });

  test("getArtifacts", () => {
    const platform: string = "platform_example"
    return expect(instance.getArtifacts(platform, {})).resolves.toBe(null)
  })
  test("getDomainConfiguration", () => {
    return expect(instance.getDomainConfiguration({})).resolves.toBe(null)
  })
  test("getTenantConnectorConfigurations", () => {
    return expect(instance.getTenantConnectorConfigurations({})).resolves.toBe(null)
  })
  test("putDomainConfiguration", () => {
    const body: api.DomainConfiguration = undefined
    return expect(instance.putDomainConfiguration(body, {})).resolves.toBe(null)
  })
})

describe("InfrastructureFeaturesApi", () => {
  let instance: api.InfrastructureFeaturesApi
  beforeEach(function() {
    instance = new api.InfrastructureFeaturesApi(config)
  });

  test("getCapabilities", () => {
    const facilityId: string = "facilityId_example"
    return expect(instance.getCapabilities(facilityId, {})).resolves.toBe(null)
  })
  test("getFeature", () => {
    const featureName: string = "featureName_example"
    return expect(instance.getFeature(featureName, {})).resolves.toBe(null)
  })
  test("getFeatures", () => {
    return expect(instance.getFeatures({})).resolves.toBe(null)
  })
  test("patchFeature", () => {
    const body: api.FeaturePatchActions = undefined
    const featureName: string = "featureName_example"
    return expect(instance.patchFeature(body, featureName, {})).resolves.toBe(null)
  })
})

describe("InfrastructureGraphQLApi", () => {
  let instance: api.InfrastructureGraphQLApi
  beforeEach(function() {
    instance = new api.InfrastructureGraphQLApi(config)
  });

  test("executeGraphQLCommand", () => {
    return expect(instance.executeGraphQLCommand({})).resolves.toBe(null)
  })
  test("getGraphQLPlayground", () => {
    return expect(instance.getGraphQLPlayground({})).resolves.toBe(null)
  })
})

describe("InfrastructureHealthApi", () => {
  let instance: api.InfrastructureHealthApi
  beforeEach(function() {
    instance = new api.InfrastructureHealthApi(config)
  });

  test("healthCheck", () => {
    return expect(instance.healthCheck({})).resolves.toBe(null)
  })
  test("status", () => {
    return expect(instance.status({})).resolves.toBe(null)
  })
})

describe("InfrastructureOIDCConfigurationApi", () => {
  let instance: api.InfrastructureOIDCConfigurationApi
  beforeEach(function() {
    instance = new api.InfrastructureOIDCConfigurationApi(config)
  });

  test("createOidcProvider", () => {
    const body: api.OidcProviderForCreation = undefined
    return expect(instance.createOidcProvider(body, {})).resolves.toBe(null)
  })
  test("deleteOidcProvider", () => {
    const oidcProviderId: string = "oidcProviderId_example"
    return expect(instance.deleteOidcProvider(oidcProviderId, {})).resolves.toBe(null)
  })
  test("getOidcProvider", () => {
    const oidcProviderId: string = "oidcProviderId_example"
    return expect(instance.getOidcProvider(oidcProviderId, {})).resolves.toBe(null)
  })
  test("getOidcProviders", () => {
    return expect(instance.getOidcProviders({})).resolves.toBe(null)
  })
  test("updateOidcProvider", () => {
    const oidcProviderId: string = "oidcProviderId_example"
    const body: api.OidcProviderForUpdate = undefined
    return expect(instance.updateOidcProvider(oidcProviderId, body, {})).resolves.toBe(null)
  })
})

describe("InventoryManagementChannelAvailabilityApi", () => {
  let instance: api.InventoryManagementChannelAvailabilityApi
  beforeEach(function() {
    instance = new api.InventoryManagementChannelAvailabilityApi(config)
  });

  test("createAllocationUnderGroup", () => {
    const body: api.AvailabilityAllocationForCreationUnderGroup = undefined
    const groupId: string = "groupId_example"
    const availabilityChannelId: string = "availabilityChannelId_example"
    return expect(instance.createAllocationUnderGroup(body, groupId, availabilityChannelId, {})).resolves.toBe(null)
  })
  test("createAvailabilityChannel", () => {
    const body: api.AvailabilityChannelForCreation = undefined
    return expect(instance.createAvailabilityChannel(body, {})).resolves.toBe(null)
  })
  test("createGroupUnderChannel", () => {
    const body: api.AvailabilityAllocationGroupForCreationUnderChannel = undefined
    const availabilityChannelId: string = "availabilityChannelId_example"
    return expect(instance.createGroupUnderChannel(body, availabilityChannelId, {})).resolves.toBe(null)
  })
  test("deleteAllocationUnderGroup", () => {
    const allocationId: string = "allocationId_example"
    const groupId: string = "groupId_example"
    const availabilityChannelId: string = "availabilityChannelId_example"
    return expect(instance.deleteAllocationUnderGroup(allocationId, groupId, availabilityChannelId, {})).resolves.toBe(null)
  })
  test("deleteAvailabilityChannel", () => {
    const availabilityChannelId: string = "availabilityChannelId_example"
    return expect(instance.deleteAvailabilityChannel(availabilityChannelId, {})).resolves.toBe(null)
  })
  test("deleteGroupUnderChannel", () => {
    const groupId: string = "groupId_example"
    const availabilityChannelId: string = "availabilityChannelId_example"
    return expect(instance.deleteGroupUnderChannel(groupId, availabilityChannelId, {})).resolves.toBe(null)
  })
  test("getAllocationUnderGroupById", () => {
    const groupId: string = "groupId_example"
    const allocationId: string = "allocationId_example"
    const availabilityChannelId: string = "availabilityChannelId_example"
    return expect(instance.getAllocationUnderGroupById(groupId, allocationId, availabilityChannelId, {})).resolves.toBe(null)
  })
  test("getAllocationsUnderGroup", () => {
    const groupId: string = "groupId_example"
    const availabilityChannelId: string = "availabilityChannelId_example"
    const searchTerm: string = "searchTerm_example"
    const searchTermExact: string = "searchTermExact_example"
    const size: number = 1.2
    const startAfterId: string = "startAfterId_example"
    return expect(instance.getAllocationsUnderGroup(groupId, availabilityChannelId, searchTerm, searchTermExact, size, startAfterId, {})).resolves.toBe(null)
  })
  test("getAvailabilityChannelById", () => {
    const availabilityChannelId: string = "availabilityChannelId_example"
    return expect(instance.getAvailabilityChannelById(availabilityChannelId, {})).resolves.toBe(null)
  })
  test("getAvailabilityChannels", () => {
    const searchTerm: string = "searchTerm_example"
    const searchTermExact: string = "searchTermExact_example"
    const strategy: string = "strategy_example"
    const size: number = 1.2
    const startAfterId: string = "startAfterId_example"
    return expect(instance.getAvailabilityChannels(searchTerm, searchTermExact, strategy, size, startAfterId, {})).resolves.toBe(null)
  })
  test("getGroupUnderChannelById", () => {
    const availabilityChannelId: string = "availabilityChannelId_example"
    const groupId: string = "groupId_example"
    return expect(instance.getGroupUnderChannelById(availabilityChannelId, groupId, {})).resolves.toBe(null)
  })
  test("getGroupsUnderChannel", () => {
    const availabilityChannelId: string = "availabilityChannelId_example"
    const searchTerm: string = "searchTerm_example"
    const searchTermExact: string = "searchTermExact_example"
    const size: number = 1.2
    const startAfterId: string = "startAfterId_example"
    return expect(instance.getGroupsUnderChannel(availabilityChannelId, searchTerm, searchTermExact, size, startAfterId, {})).resolves.toBe(null)
  })
  test("replaceAllocationUnderGroup", () => {
    const body: api.AvailabilityAllocationForReplacement = undefined
    const groupId: string = "groupId_example"
    const allocationId: string = "allocationId_example"
    const availabilityChannelId: string = "availabilityChannelId_example"
    return expect(instance.replaceAllocationUnderGroup(body, groupId, allocationId, availabilityChannelId, {})).resolves.toBe(null)
  })
  test("replaceAvailabilityChannel", () => {
    const body: api.AvailabilityChannelForReplacement = undefined
    const availabilityChannelId: string = "availabilityChannelId_example"
    return expect(instance.replaceAvailabilityChannel(body, availabilityChannelId, {})).resolves.toBe(null)
  })
  test("replaceGroupUnderChannel", () => {
    const body: api.AvailabilityAllocationGroupForReplacement = undefined
    const availabilityChannelId: string = "availabilityChannelId_example"
    const groupId: string = "groupId_example"
    return expect(instance.replaceGroupUnderChannel(body, availabilityChannelId, groupId, {})).resolves.toBe(null)
  })
})

describe("InventoryManagementInboundApi", () => {
  let instance: api.InventoryManagementInboundApi
  beforeEach(function() {
    instance = new api.InventoryManagementInboundApi(config)
  });

  test("addReceiptToInboundProcess", () => {
    const body: api.InboundReceiptForCreation = undefined
    const inboundProcessId: string = "inboundProcessId_example"
    return expect(instance.addReceiptToInboundProcess(body, inboundProcessId, {})).resolves.toBe(null)
  })
  test("createAttachment", () => {
    const body: api.InboundAttachmentForCreation = undefined
    return expect(instance.createAttachment(body, {})).resolves.toBe(null)
  })
  test("createInboundProcess", () => {
    const body: api.InboundProcessForCreation = undefined
    return expect(instance.createInboundProcess(body, {})).resolves.toBe(null)
  })
  test("createPurchaseOrder", () => {
    const body: api.PurchaseOrderForCreation = undefined
    return expect(instance.createPurchaseOrder(body, {})).resolves.toBe(null)
  })
  test("createReceipt", () => {
    const body: api.ReceiptForCreation = undefined
    return expect(instance.createReceipt(body, {})).resolves.toBe(null)
  })
  test("deleteInboundProcess", () => {
    const inboundProcessId: string = "inboundProcessId_example"
    return expect(instance.deleteInboundProcess(inboundProcessId, {})).resolves.toBe(null)
  })
  test("deleteReceipt", () => {
    const receiptId: string = "receiptId_example"
    const version: number = 1.2
    return expect(instance.deleteReceipt(receiptId, version, {})).resolves.toBe(null)
  })
  test("getInboundProcess", () => {
    const inboundProcessId: string = "inboundProcessId_example"
    return expect(instance.getInboundProcess(inboundProcessId, {})).resolves.toBe(null)
  })
  test("getInboundProcesses", () => {
    const size: number = 1.2
    const startAfterId: string = "startAfterId_example"
    const sort: string = "sort_example"
    const facilityRef: Array<string> = undefined
    const status: Array<string> = undefined
    const searchTerm: string = "searchTerm_example"
    const searchTermExact: string = "searchTermExact_example"
    const purchaseOrderCancelled: boolean = true
    const receiptStatus: Array<string> = undefined
    return expect(instance.getInboundProcesses(size, startAfterId, sort, facilityRef, status, searchTerm, searchTermExact, purchaseOrderCancelled, receiptStatus, {})).resolves.toBe(null)
  })
  test("getInboundReceiptJob", () => {
    const inboundEntryId: string = "inboundEntryId_example"
    return expect(instance.getInboundReceiptJob(inboundEntryId, {})).resolves.toBe(null)
  })
  test("getInboundReceiptJobs", () => {
    const size: number = 1.2
    const startAfterId: string = "startAfterId_example"
    const facilityRef: Array<string> = undefined
    const status: Array<string> = undefined
    const searchTerm: string = "searchTerm_example"
    const searchTermExact: string = "searchTermExact_example"
    const fromDate: Date = 2013-10-20T19:20:30+01:00
    const toDate: Date = 2013-10-20T19:20:30+01:00
    return expect(instance.getInboundReceiptJobs(size, startAfterId, facilityRef, status, searchTerm, searchTermExact, fromDate, toDate, {})).resolves.toBe(null)
  })
  test("getPurchaseOrder", () => {
    const purchaseOrderId: string = "purchaseOrderId_example"
    return expect(instance.getPurchaseOrder(purchaseOrderId, {})).resolves.toBe(null)
  })
  test("getReceipt", () => {
    const receiptId: string = "receiptId_example"
    return expect(instance.getReceipt(receiptId, {})).resolves.toBe(null)
  })
  test("getSignedAttachmentUrl", () => {
    const attachmentId: string = "attachmentId_example"
    return expect(instance.getSignedAttachmentUrl(attachmentId, {})).resolves.toBe(null)
  })
  test("patchInboundProcess", () => {
    const body: api.InboundProcessForPatch = undefined
    const inboundProcessId: string = "inboundProcessId_example"
    return expect(instance.patchInboundProcess(body, inboundProcessId, {})).resolves.toBe(null)
  })
  test("patchPurchaseOrder", () => {
    const body: api.PurchaseOrderForPartialUpdate = undefined
    const purchaseOrderId: string = "purchaseOrderId_example"
    return expect(instance.patchPurchaseOrder(body, purchaseOrderId, {})).resolves.toBe(null)
  })
  test("patchReceipt", () => {
    const body: api.InboundReceiptForPatch = undefined
    const receiptId: string = "receiptId_example"
    return expect(instance.patchReceipt(body, receiptId, {})).resolves.toBe(null)
  })
  test("putReceipt", () => {
    const body: api.InboundReceiptForUpdate = undefined
    const receiptId: string = "receiptId_example"
    return expect(instance.putReceipt(body, receiptId, {})).resolves.toBe(null)
  })
  test("upsertInboundProcessPurchaseOrder", () => {
    const body: api.InboundProcessPurchaseOrderForUpsert = undefined
    const inboundProcessId: string = "inboundProcessId_example"
    return expect(instance.upsertInboundProcessPurchaseOrder(body, inboundProcessId, {})).resolves.toBe(null)
  })
  test("upsertPurchaseOrder", () => {
    const body: api.PurchaseOrderForUpdate = undefined
    const purchaseOrderId: string = "purchaseOrderId_example"
    return expect(instance.upsertPurchaseOrder(body, purchaseOrderId, {})).resolves.toBe(null)
  })
})

describe("InventoryManagementStocksApi", () => {
  let instance: api.InventoryManagementStocksApi
  beforeEach(function() {
    instance = new api.InventoryManagementStocksApi(config)
  });

  test("bulkUpdateFacilityStock", () => {
    const body: api.FacilityStockBulkOperations = undefined
    const facilityId: string = "facilityId_example"
    return expect(instance.bulkUpdateFacilityStock(body, facilityId, {})).resolves.toBe(null)
  })
  test("bulkUpdateSafetyStock", () => {
    const body: api.SafetyStockBulkOperations = undefined
    return expect(instance.bulkUpdateSafetyStock(body, {})).resolves.toBe(null)
  })
  test("createStock", () => {
    const body: api.StockForCreation = undefined
    return expect(instance.createStock(body, {})).resolves.toBe(null)
  })
  test("deleteSafetyStock", () => {
    const safetyStockId: string = "safetyStockId_example"
    return expect(instance.deleteSafetyStock(safetyStockId, {})).resolves.toBe(null)
  })
  test("deleteStock", () => {
    const stockId: string = "stockId_example"
    return expect(instance.deleteStock(stockId, {})).resolves.toBe(null)
  })
  test("getArticles", () => {
    const size: number = 1.2
    const startAfterId: string = "startAfterId_example"
    const facilityRef: string = "facilityRef_example"
    const searchTerm: string = "searchTerm_example"
    const locale: SupportedLocale = "locale_example"
    const tenantArticleId: string = "tenantArticleId_example"
    return expect(instance.getArticles(size, startAfterId, facilityRef, searchTerm, locale, tenantArticleId, {})).resolves.toBe(null)
  })
  test("getFacilityStockConfiguration", () => {
    const facilityId: string = "facilityId_example"
    return expect(instance.getFacilityStockConfiguration(facilityId, {})).resolves.toBe(null)
  })
  test("getFacilityStocks", () => {
    const facilityId: string = "facilityId_example"
    const size: number = 1.2
    const startAfterId: string = "startAfterId_example"
    return expect(instance.getFacilityStocks(facilityId, size, startAfterId, {})).resolves.toBe(null)
  })
  test("getForecastsForArticle", () => {
    const tenantArticleId: string = "tenantArticleId_example"
    const period: string = "period_example"
    return expect(instance.getForecastsForArticle(tenantArticleId, period, {})).resolves.toBe(null)
  })
  test("getInventoryConfigurations", () => {
    return expect(instance.getInventoryConfigurations({})).resolves.toBe(null)
  })
  test("getInventoryFacilityConfigurations", () => {
    const facilityId: string = "facilityId_example"
    return expect(instance.getInventoryFacilityConfigurations(facilityId, {})).resolves.toBe(null)
  })
  test("getSafetyStocks", () => {
    const size: number = 1.2
    const startAfterId: string = "startAfterId_example"
    const tenantArticleId: string = "tenantArticleId_example"
    const facilityRef: string = "facilityRef_example"
    return expect(instance.getSafetyStocks(size, startAfterId, tenantArticleId, facilityRef, {})).resolves.toBe(null)
  })
  test("getStock", () => {
    const stockId: string = "stockId_example"
    return expect(instance.getStock(stockId, {})).resolves.toBe(null)
  })
  test("getStockConfiguration", () => {
    return expect(instance.getStockConfiguration({})).resolves.toBe(null)
  })
  test("getStockDistribution", () => {
    const tenantArticleId: string = "tenantArticleId_example"
    const facilityServiceTypes: Array<string> = undefined
    const facilityStatus: Array<string> = undefined
    const facilityName: string = "facilityName_example"
    const facilityIds: Array<string> = undefined
    const channelRefs: Array<string> = undefined
    return expect(instance.getStockDistribution(tenantArticleId, facilityServiceTypes, facilityStatus, facilityName, facilityIds, channelRefs, {})).resolves.toBe(null)
  })
  test("getStockSummaries", () => {
    const size: number = 1.2
    const startAfterId: string = "startAfterId_example"
    const facilityServiceTypes: Array<string> = undefined
    const facilityStatus: Array<string> = undefined
    const facilityRefs: Array<string> = undefined
    const allowStale: boolean = true
    const tenantArticleIds: Array<string> = undefined
    const channelRefs: Array<string> = undefined
    return expect(instance.getStockSummaries(size, startAfterId, facilityServiceTypes, facilityStatus, facilityRefs, allowStale, tenantArticleIds, channelRefs, {})).resolves.toBe(null)
  })
  test("getStockSummariesDeprecated", () => {
    const size: number = 1.2
    const startAfterId: string = "startAfterId_example"
    const facilityServiceTypes: Array<string> = undefined
    const facilityStatus: Array<string> = undefined
    const facilityRefs: Array<string> = undefined
    const allowStale: boolean = true
    const tenantArticleIds: Array<string> = undefined
    const channelRefs: Array<string> = undefined
    return expect(instance.getStockSummariesDeprecated(size, startAfterId, facilityServiceTypes, facilityStatus, facilityRefs, allowStale, tenantArticleIds, channelRefs, {})).resolves.toBe(null)
  })
  test("getStocks", () => {
    const facilityRef: string = "facilityRef_example"
    const tenantArticleId: Array<string> = undefined
    const locationRef: Array<string> = undefined
    const size: number = 1.2
    const startAfterId: string = "startAfterId_example"
    return expect(instance.getStocks(facilityRef, tenantArticleId, locationRef, size, startAfterId, {})).resolves.toBe(null)
  })
  test("getStorageLocationRecommendations", () => {
    const stockId: string = "stockId_example"
    return expect(instance.getStorageLocationRecommendations(stockId, {})).resolves.toBe(null)
  })
  test("patchFacilityConfiguration", () => {
    const body: api.StockConfigurationPatchActions = undefined
    const facilityId: string = "facilityId_example"
    return expect(instance.patchFacilityConfiguration(body, facilityId, {})).resolves.toBe(null)
  })
  test("performStocksActions", () => {
    const body: api.StockAction = undefined
    return expect(instance.performStocksActions(body, {})).resolves.toBe(null)
  })
  test("putStockConfiguration", () => {
    const body: api.StockConfiguration = undefined
    return expect(instance.putStockConfiguration(body, {})).resolves.toBe(null)
  })
  test("updateStock", () => {
    const body: api.StocksStockIdBody = undefined
    const stockId: string = "stockId_example"
    return expect(instance.updateStock(body, stockId, {})).resolves.toBe(null)
  })
  test("upsertInventoryConfigurations", () => {
    const body: api.InventoryConfigurationForPatch = undefined
    return expect(instance.upsertInventoryConfigurations(body, {})).resolves.toBe(null)
  })
  test("upsertInventoryFacilityConfigurations", () => {
    const body: api.InventoryFacilityConfigurationForPatch = undefined
    const facilityId: string = "facilityId_example"
    return expect(instance.upsertInventoryFacilityConfigurations(body, facilityId, {})).resolves.toBe(null)
  })
  test("upsertStocks", () => {
    const body: api.StocksForUpsert = undefined
    return expect(instance.upsertStocks(body, {})).resolves.toBe(null)
  })
})

describe("LastMileIntegrationCarriersApi", () => {
  let instance: api.LastMileIntegrationCarriersApi
  beforeEach(function() {
    instance = new api.LastMileIntegrationCarriersApi(config)
  });

  test("addCarrier", () => {
    const body: api.CarrierForCreation = undefined
    const locale: string = "locale_example"
    return expect(instance.addCarrier(body, locale, {})).resolves.toBe(null)
  })
  test("createCarrierCountryServiceMapping", () => {
    const body: api.CarrierCountryServiceMappingForCreation = undefined
    const carrierId: string = "carrierId_example"
    return expect(instance.createCarrierCountryServiceMapping(body, carrierId, {})).resolves.toBe(null)
  })
  test("deleteCarrierCountryServiceMapping", () => {
    const carrierId: string = "carrierId_example"
    const countryServiceMappingId: string = "countryServiceMappingId_example"
    return expect(instance.deleteCarrierCountryServiceMapping(carrierId, countryServiceMappingId, {})).resolves.toBe(null)
  })
  test("getCarrier", () => {
    const carrierId: string = "carrierId_example"
    const locale: string = "locale_example"
    return expect(instance.getCarrier(carrierId, locale, {})).resolves.toBe(null)
  })
  test("getCarrierConfiguration", () => {
    const carrierId: string = "carrierId_example"
    return expect(instance.getCarrierConfiguration(carrierId, {})).resolves.toBe(null)
  })
  test("getCarrierCountryServiceMapping", () => {
    const carrierId: string = "carrierId_example"
    const countryServiceMappingId: string = "countryServiceMappingId_example"
    return expect(instance.getCarrierCountryServiceMapping(carrierId, countryServiceMappingId, {})).resolves.toBe(null)
  })
  test("getCarrierCountryServiceMappings", () => {
    const carrierId: string = "carrierId_example"
    return expect(instance.getCarrierCountryServiceMappings(carrierId, {})).resolves.toBe(null)
  })
  test("getCarriers", () => {
    const startAfterId: string = "startAfterId_example"
    const size: number = 56
    const locale: string = "locale_example"
    return expect(instance.getCarriers(startAfterId, size, locale, {})).resolves.toBe(null)
  })
  test("patchCarrier", () => {
    const body: api.CarrierPatchActions = undefined
    const carrierId: string = "carrierId_example"
    const locale: string = "locale_example"
    return expect(instance.patchCarrier(body, carrierId, locale, {})).resolves.toBe(null)
  })
  test("putCarrierConfiguration", () => {
    const body: api.CarrierIdConfigurationBody = undefined
    const carrierId: string = "carrierId_example"
    return expect(instance.putCarrierConfiguration(body, carrierId, {})).resolves.toBe(null)
  })
  test("updateCarrierCountryServiceMapping", () => {
    const body: api.CarrierCountryServiceMappingForUpdate = undefined
    const carrierId: string = "carrierId_example"
    const countryServiceMappingId: string = "countryServiceMappingId_example"
    return expect(instance.updateCarrierCountryServiceMapping(body, carrierId, countryServiceMappingId, {})).resolves.toBe(null)
  })
})