@springtree/eva-core/EVA.UserTasks.d.ts

The EVA core typings

declare module EVA.UserTasks {

  export namespace Errors {
    export namespace ZonedCycleCount {
      export const DateTooSoon = 'ZonedCycleCount:DateTooSoon';
      export const NoOrganizationUnitFilters = 'ZonedCycleCount:NoOrganizationUnitFilters';
      export const PlanInProgress = 'ZonedCycleCount:PlanInProgress';
      export const NoOrganizationUnits = 'ZonedCycleCount:NoOrganizationUnits';
      export const NoProductFilters = 'ZonedCycleCount:NoProductFilters';
    }

  }


  export interface CompleteZonedCycleCountPreCount {
    UserTaskID: number;
    Results: CompleteZonedCycleCountPreCountResult[];
  }

  export interface CompleteZonedCycleCountPreCountResult {
    StockLabelID: number;
    CountedQuantity: number;
    Resources: { [key: string]: string }[];
  }

  export interface CompleteZonedCycleCounts {
    ToComplete: ZonedCycleCountToComplete[];
    CompletionType: CompleteZonedCycleCountCompletionTypes;
  }

  export interface ZonedCycleCountToComplete {
    UserTaskID: number;
    CountedQuantityCorrections: ZonedCycleCountToCompleteQuantityCorrection[];
  }

  export interface ZonedCycleCountToCompleteQuantityCorrection {
    StockLabelID: number;
    NewCountedQuantity: number;
  }

  export const enum CompleteZonedCycleCountCompletionTypes {
    AcceptPreCount = 0,
    Recount = 1
  }

  export interface CountStockLabelForZonedCycleCount {
    UserTaskID: number;
    StockLabelID: number;
    CountedQuantity: number;
    Resources?: { [key: string]: string }[];
  }

  export interface CountStockLabelForZonedCycleCountResponse {
    CountResult: ZonedCycleCountResultTypes;
    IsCompleted: boolean;
    Error: EVA.Core.ServiceError;
  }

  export const enum ZonedCycleCountResultTypes {
    Accepted = 0,
    Recount = 1,
    CompleteResources = 2
  }

  export interface CreateZonedCycleCount {
    OrganizationUnitID: number;
    ProductID: number;
  }

  export interface CreateZonedCycleCounts {
    OrganizationUnitIDs?: number[];
    ProductIDs?: number[];
  }

  export interface CreateZonedCycleCountsByQuery {
    Query?: string;
    Filters?: { [key: string]: EVA.Core.FilterModel };
    OrganizationUnitFilter?: OrganizationUnitFilterModel;
    /**
     * Obsolete, please use the OrganizationUnitFilter
     */
    OrganizationUnitIDs?: number[];
  }

  export interface OrganizationUnitFilterModel {
    IDs: number[];
    BackendIDs: string[];
    CountryIDs: string[];
    StatusID: number;
  }

  export interface CreateCycleCountZoneGroup {
    Name: string;
    OrganizationUnitSetID: number;
    ZoneIDs?: number[];
  }

  export interface UpdateCycleCountZoneGroup {
    ID: number;
    Name: string;
    OrganizationUnitSetID: number;
    ZoneIDs?: number[];
  }

  export interface DeleteCycleCountZoneGroup {
    ID: number;
  }

  export interface ListCycleCountZoneGroups {
    PageConfig?: EVA.Core.PageConfig<ListCycleCountGroupsFilter>;
  }

  export interface ListCycleCountGroupsFilter {
    Name: string;
    OrganizationUnitID: number;
    OrganizationUnitSetID: number;
    CycleCountZoneID: number;
  }

  export interface ListCycleCountZoneGroupsResponse {
    Result: EVA.Core.PagedResult<CycleCountZoneGroupDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface CycleCountZoneGroupDto {
    Name: string;
    OrganizationUnitSetID: number;
    OrganizationUnitSetName: string;
    Zones: EVA.Core.EnumDto[];
  }

  export interface CreateCycleCountZone {
    Name: string;
    Description?: string;
  }

  export interface UpdateCycleCountZone {
    ID: number;
    Name: string;
    Description?: string;
  }

  export interface DeleteCycleCountZone {
    ID: number;
  }

  export interface GetCycleCountZones {
  }

  export interface GetCycleCountZonesResponse {
    Result: CycleCountZoneDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface CycleCountZoneDto {
    ID: number;
    Name: string;
    Description: string;
  }

  export interface ReplaceCycleCountZonesForOrganizationUnit {
    OrganizationUnitID: number;
    CycleCountZoneIDs?: number[];
  }

  export interface ListCycleZonesForOrganizationUnits {
    PageConfig?: EVA.Core.PageConfig<ListOrganizationUnitCycleCountZonesFilter>;
  }

  export interface ListOrganizationUnitCycleCountZonesFilter {
    OrganizationUnitID: number;
  }

  export interface ListCycleZonesForOrganizationUnitsResponse {
    Result: EVA.Core.PagedResult<CycleCountZonesForOrganizationUnitDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface CycleCountZonesForOrganizationUnitDto {
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    Zones: CycleCountZoneDto[];
  }

  export interface DeactivateZonedCycleCount {
    UserTaskIDs?: number[];
  }

  /**
   * Gets the status of the pre-counts of a cyclecount, if any. The input for this service is either the ID of the main count task (`ZonedCycleCountUserTaskID`)
   * or the ID of a pre-count task (`PreCountUserTaskID`). If `PreCountUserTaskID` is specified, it returns the status of the sibling pre-counts.
   */
  export interface GetStatusForZonedCycleCountPreCounts {
    ZonedCycleCountUserTaskID: number;
    PreCountUserTaskID: number;
  }

  export interface GetStatusForZonedCycleCountPreCountsResponse {
    PreCounts: PreCountStatus[];
    Error: EVA.Core.ServiceError;
  }

  export interface PreCountStatus {
    CycleCountZone: EVA.Core.EnumDto;
    IsCompleted: boolean;
    IsStarted: boolean;
    UserID: number;
    UserFullName: string;
    CompletionTime?: string;
    PreCountedQuantity: number;
    CountResults: Result[];
  }

  export interface Result {
    StockLabel: EVA.Core.EnumDto;
    CountedQuantity: number;
    CreationTime?: string;
  }

  /**
   * Returns a detailed view of a ZonedCycleCountPreCount by the ID of its UserTask.
   * 
   * The response contains:
   * 
   * - Which StockLabels to count (`StockLabelsToCount`)
   * - The product that needs to be counted (`Product`); this product contains all the fields in its `Content` object that were requested through the `IncludedFields` property on the request, or a default set of fields if not specified
   * - Zone that needs to be counted (`CycleCountZone`)
   * - List of stock labels to be counted (`StockLabelsToCount`)
   * - List of required resource types (`RequiredResourceTypes`)
   */
  export interface GetZonedCycleCountPreCount {
    UserTaskID: number;
    IncludedFields?: string[];
  }

  export interface GetZonedCycleCountPreCountResponse {
    ID: number;
    UserTaskID: number;
    CycleCountZone: EVA.Core.EnumDto;
    StockLabelsToCount: EVA.Core.EnumDto[];
    Product: GetZonedCycleCountPreCountProduct;
    RequiredResourceTypes: EVA.Core.StockResourceTypeDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface GetZonedCycleCountPreCountProduct {
    ID: number;
    CustomID: string;
    Type: EVA.Core.ProductTypes;
    Content: EVA.Core.IProductSearchItem;
    UnitPriceInTax?: number;
    CurrencyID: string;
  }

  /**
   * Returns a detailed view of a ZonedCycleCount by the ID of its UserTask.
   * 
   * The response contains:
   * 
   * - Which StockLabels to count (`StockLabelsToCount`)
   * - The product that needs to be counted. This product contains all the fields in its `Content` object that were requested through the `IncludedFields` property on the request, or a default set of fields if not specified.
   * - Which StockMutations have been created since the first pre-count (if any) per StockLabel (`StockMutationsSincePreCount`)
   * - A list of all pre-counts, complete with the zone that needs to be counted, the user who did the count (if the count already happened) and a list of count results per StockLabel
   * - A list of pre-counted quantityies per StockLabel (`PreCountedQuantities`)
   * - A list of the total quantity of stock mutated per StockLabel (a summary of `StockMutationsSincePreCount`).
   * - The current stock per StockLabel
   * - ExpectedPreCountedQuantity: This is stored on the ZonedCyleCount the moment the last pre-count has been completed, and is a sum of the expected Stock at that moment.
   * - PreCountedQuantity: The quantity that was actually counted in all pre-counts over all StockLabels. This is recorded when all pre-counts have been completed.
   */
  export interface GetZonedCycleCount {
    ID: number;
    IncludedFields?: string[];
  }

  export interface GetZonedCycleCountResponse {
    StockLabelsToCount: EVA.Core.EnumDto[];
    Product: GetZonedCycleCountProduct;
    StockMutationsSincePreCount: GetZonedCycleCountStockMutation[];
    PreCounts: GetZonedCycleCountPreCountDto[];
    PreCountedQuantities: GetZonedCycleCountPreCountedQuantity[];
    StockMutationQuantitiesSincePreCount: GetZonedCycleCountStockMutationQuantity[];
    /**
     * @deprecated Replaced with StockLabelQuantities
     */
    CurrentStock: GetZonedCyleCountStockLabelQuantities[];
    StockLabelQuantities: GetZonedCyleCountStockLabelQuantities[];
    ExpectedPreCountedQuantity: number;
    PreCountedQuantity: number;
    Error: EVA.Core.ServiceError;
  }

  export interface GetZonedCycleCountProduct {
    ID: number;
    CustomID: string;
    Type: EVA.Core.ProductTypes;
    Content: EVA.Core.IProductSearchItem;
  }

  export interface GetZonedCycleCountStockMutation {
    StockLabel: EVA.Core.EnumDto;
    StockMutationReason: EVA.Core.EnumDto;
    MutationQuantity: number;
    CreationTime?: string;
  }

  export interface GetZonedCycleCountPreCountDto {
    CycleCountZone: EVA.Core.EnumDto;
    User: GetZonedCycleCountPreCountUserDto;
    Results: GetZonedCycleCountPreCountResult[];
  }

  export interface GetZonedCycleCountPreCountUserDto {
    ID: number;
    Name: string;
  }

  export interface GetZonedCycleCountPreCountResult {
    StockLabel: EVA.Core.EnumDto;
    CountedQuantity: number;
    CreationTime?: string;
    CurrentStock: number;
  }

  export interface GetZonedCycleCountPreCountedQuantity {
    StockLabel: EVA.Core.EnumDto;
    CountedQuantity: number;
  }

  export interface GetZonedCycleCountStockMutationQuantity {
    TotalMutationQuantity: number;
    Since?: string;
    StockLabel: EVA.Core.EnumDto;
  }

  export interface GetZonedCyleCountStockLabelQuantities {
    StockLabel: EVA.Core.EnumDto;
    CurrentQuantityOnHand: number;
    ExpectedQuantity: number;
    CountedQuantity: number;
    ModifiedQuantity: number;
  }

  export interface ListZonedCycleCounts {
    PageConfig?: EVA.Core.PageConfig<ListZonedCycleCountsFilter>;
  }

  export interface ListZonedCycleCountsFilter {
    OrganizationUnitID: number;
    ProductID: number;
    IsCompleted: boolean;
    InProgress: boolean;
    ResultStatus?: ZonedCycleCountResultStatus;
    IsActive: boolean;
    UserTaskIDs: number[];
    FromDate?: string;
    ToDate?: string;
  }

  export const enum ZonedCycleCountResultStatus {
    None = 0,
    Correct = 1,
    RecountRequested = 2,
    Modified = 4,
    Deviated = 8
  }

  export interface ListZonedCycleCountsResponse {
    Result: EVA.Core.PagedResult<ListZonedCycleCountsDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface ListZonedCycleCountsDto {
    ID: number;
    UserTaskID: number;
    IsCompleted: boolean;
    IsActive: boolean;
    UserID: number;
    UserName: string;
    ResultStatus?: ZonedCycleCountResultStatus;
    CreationTime?: string;
    StartTime?: string;
    CompletionTime?: string;
    ProductID: number;
    CustomID: string;
    ProductBarcode: string;
    ProductDisplayValue: string;
    ExpectedPreCountedQuantity: number;
    PreCountedQuantity: number;
    DeviationPercentage?: number;
    FinishedPreCountTasks: number;
    TotalPreCountTasks: number;
    PreCountProgression?: number;
  }

  export interface ProduceZonedCycleCountHandout {
    CycleCountZoneIDs: number[];
    OrganizationUnitID: number;
    StationID: number;
    Channel: EVA.Core.TemplateOutputChannel;
  }

  export interface ProduceZonedCycleCountHandoutResponse {
    Url: string;
    Error: EVA.Core.ServiceError;
  }

  /**
   * Starts a ZonedCycleCountPreCount by the ID of its UserTask.
   * 
   * The response contains:
   * 
   * - Which StockLabels to count (`StockLabelsToCount`)
   * - The product that needs to be counted (`Product`); this product contains all the fields in its `Content` object that were requested through the `IncludedFields` property on the request, or a default set of fields if not specified
   * - Zone that needs to be counted (`CycleCountZone`)
   * - List of stock labels to be counted (`StockLabelsToCount`)
   * - List of required resource types (`RequiredResourceTypes`)
   */
  export interface StartZonedCycleCountPreCount {
    UserTaskID: number;
    IncludedFields?: string[];
  }

  export interface StartZonedCycleCountPreCountResponse {
    ID: number;
    UserTaskID: number;
    CycleCountZone: EVA.Core.EnumDto;
    StockLabelsToCount: EVA.Core.EnumDto[];
    Product: StartZonedCycleCountPreCountProduct;
    RequiredResourceTypes: EVA.Core.StockResourceTypeDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface StartZonedCycleCountPreCountProduct {
    ID: number;
    CustomID: string;
    Type: EVA.Core.ProductTypes;
    Content: EVA.Core.IProductSearchItem;
    UnitPriceInTax?: number;
    CurrencyID: string;
  }

  export interface StartZonedCycleCount {
    UserTaskID: number;
    IncludedFields?: string[];
  }

  export interface StartZonedCycleCountResponse {
    ID: number;
    UserTaskID: number;
    StockLabelsToCount: EVA.Core.EnumDto[];
    Product: StartZonedCycleCountProduct;
    StockMutationsSincePreCount: StartZonedCycleCountStockMutation[];
    StockMutationQuantitiesSincePreCount: StartZonedCycleCountStockMutationQuantity[];
    PreCounts: StartZonedCycleCountPreCountDto[];
    PreCountedQuantities: StartZonedCycleCountPreCountedQuantity[];
    CurrentStock: StartZonedCyleCountCurrentStock[];
    RequiredResourceTypes: EVA.Core.StockResourceTypeDto[];
    ExpectedPreCountedQuantity: number;
    PreCountedQuantity: number;
    Error: EVA.Core.ServiceError;
  }

  export interface StartZonedCycleCountProduct {
    ID: number;
    CustomID: string;
    Type: EVA.Core.ProductTypes;
    Content: EVA.Core.IProductSearchItem;
    UnitPriceInTax?: number;
    CurrencyID: string;
  }

  export interface StartZonedCycleCountStockMutation {
    StockLabel: EVA.Core.EnumDto;
    StockMutationReason: EVA.Core.EnumDto;
    MutationQuantity: number;
    CreationTime?: string;
  }

  export interface StartZonedCycleCountStockMutationQuantity {
    TotalMutationQuantity: number;
    Since?: string;
    StockLabel: EVA.Core.EnumDto;
  }

  export interface StartZonedCycleCountPreCountDto {
    CycleCountZone: EVA.Core.EnumDto;
    User: StartZonedCycleCountPreCountUserDto;
    Results: StartZonedCycleCountPreCountResult[];
    IsCompleted: boolean;
  }

  export interface StartZonedCycleCountPreCountUserDto {
    ID: number;
    Name: string;
  }

  export interface StartZonedCycleCountPreCountResult {
    StockLabel: EVA.Core.EnumDto;
    CountedQuantity: number;
    CreationTime?: string;
  }

  export interface StartZonedCycleCountPreCountedQuantity {
    StockLabel: EVA.Core.EnumDto;
    CountedQuantity: number;
  }

  export interface StartZonedCyleCountCurrentStock {
    StockLabel: EVA.Core.EnumDto;
    CurrentQuantityOnHand: number;
  }

  /**
   * Updates the configuration for the provided OrganizationUnit for which days of the week EVA will generate cyclecounts.
   */
  export interface UpdateZonedCycleCountDays {
    OrganizationUnitID: number;
    DaysOfWeek: EVA.Core.DaysOfWeek;
  }

  export interface CreateZonedCycleCountPlan {
    Date?: string;
    Description?: string;
    ProductSearchModel?: ZonedCycleCountScheduleProductSearchModel;
    OrganizationUnitFilter?: ZonedCycleCountScheduleOrganizationUnitsFilter;
  }

  export interface ZonedCycleCountScheduleProductSearchModel {
    Query: string;
    Filters: { [key: string]: ZonedCycleCountScheduleProductSearchFilterModel };
  }

  export interface ZonedCycleCountScheduleProductSearchFilterModel {
    Values: any[];
    From: string;
    To: string;
    Negation: boolean;
    ExactMatch: boolean;
    IncludeMissing: boolean;
  }

  export interface ZonedCycleCountScheduleOrganizationUnitsFilter {
    IDs: number[];
    BackendIDs: string[];
    CountryIDs: string[];
    StatusID: number;
  }

  export interface CreateZonedCycleCountPlanResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface GetZonedCycleCountPlan {
    ID: number;
  }

  export interface GetZonedCycleCountPlanResponse {
    Result: ZonedCycleCountPlanDto;
    Error: EVA.Core.ServiceError;
  }

  export interface ZonedCycleCountPlanDto {
    ID: number;
    CreatedByID: number;
    CreatedByName: string;
    LastModifiedByID: number;
    LastModifiedByName: string;
    Description: string;
    StatusID: number;
    Date?: string;
    Products: ZonedCycleCountScheduleProductSearchModel;
    OrganizationUnits: ZonedCycleCountScheduleOrganizationUnitsFilter;
  }

  export interface ListZonedCycleCountPlans {
    PageConfig?: EVA.Core.PageConfig;
  }

  export interface ListZonedCycleCountPlansResponse {
    Result: EVA.Core.PagedResult<ZonedCycleCountPlanDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateZonedCycleCountPlan {
    ID: number;
    Description?: string;
    Date?: string;
    ProductSearchModel?: ZonedCycleCountScheduleProductSearchModel;
    OrganizationUnitFilter?: ZonedCycleCountScheduleOrganizationUnitsFilter;
  }

  export interface DeleteZonedCycleCountPlan {
    ID: number;
  }

  export interface CreateZonedCycleCountSchedule {
    OrganizationUnitID: number;
    Description: string;
    CycleCountIntervalInDays: number;
    ProductSearchModel?: ZonedCycleCountScheduleProductSearchModel;
  }

  export interface CreateZonedCycleCountScheduleResponse {
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    Success: boolean;
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateZonedCycleCountSchedule {
    ID: number;
    Description?: string;
    CycleCountIntervalInDays: number;
    ProductSearchModel?: ZonedCycleCountScheduleProductSearchModel;
  }

  export interface DeleteZonedCycleCountSchedule {
    ID: number;
  }

  export interface ListZonedCycleCountSchedules {
    PageConfig?: EVA.Core.PageConfig<ListZonedCycleCountSchedulesFilter>;
  }

  export interface ListZonedCycleCountSchedulesFilter {
    Description: string;
    OrganizationUnitID: number;
  }

  export interface ListZonedCycleCountSchedulesResponse {
    Result: EVA.Core.PagedResult<ZonedCycleCountScheduleDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface ZonedCycleCountScheduleDto {
    ID: number;
    Description: string;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    CycleCountIntervalInDays: number;
    SerializedProductSearchModel: string;
    ProductSearchModel: ZonedCycleCountScheduleProductSearchModel;
  }

  export interface CompleteValueAddedLogisticTask {
    UserTaskID: number;
  }

  export interface GetValueAddedLogisticTasks {
    OrderID: number;
    OrderLineIDs: number[];
  }

  export interface GetValueAddedLogisticTasksResponse {
    OrderTasks: Model[];
    OrderLineTasks: Model[];
    Error: EVA.Core.ServiceError;
  }

  export interface Model {
    OrderLineID: number;
    UserTaskID: number;
    Type: string;
    Description: string;
    Data: any;
  }

  export interface CancelUserTask {
    TaskID: number;
    UserID: number;
  }

  export interface CancelUserTaskResponse {
    Success: boolean;
    Error: EVA.Core.ServiceError;
  }

  export interface CompleteUserTask {
    WorkSet?: UserTaskWorkSet;
  }

  export interface UserTaskWorkSet {
    UserTaskID: number;
    StartTime?: string;
    Name: string;
    Description: string;
    CanBeIgnored: boolean;
    Configuration: string;
    ExpectedTimeToComplete?: string;
    Results: UserTaskResultDto[];
  }

  export interface UserTaskResultDto {
    Name: string;
    Description: string;
    Type: string;
    Value: string;
    Data: number[];
  }

  export interface CreateUserTaskSchedule {
    TypeID: number;
    OrganizationUnitTypeID: number;
    OrganizationUnitID: number;
    Description?: string;
    Deadline?: string;
    CronExpression?: string;
    AttachToFinancialPeriod: boolean;
    ApplicationID: number;
  }

  export interface CreateUserTask {
    UserID: number;
    OrganizationUnitID: number;
    AttachFinancialPeriod: boolean;
    TypeID: number;
    Deadline?: string;
    ExpectedTimeToComplete?: string;
  }

  export interface CreateUserTaskType {
    Name?: string;
    Description?: string;
    Configuration?: string;
    DefaultPriority: number;
  }

  export interface CreateUserTaskTypeResponse {
    UserTaskType: EVA.Core.UserTaskTypeDto;
    Error: EVA.Core.ServiceError;
  }

  export interface DeactivateUserTask {
    UserTaskIDs?: number[];
  }

  export interface GetUserTaskDetails {
    UserTaskID: number;
  }

  export interface GetUserTaskDetailsResponse {
    Details: UserTaskDetails;
    Error: EVA.Core.ServiceError;
  }

  export interface UserTaskDetails {
    Results: UserTaskResultDto[];
    ID: number;
    UserID: number;
    User: EVA.Core.UserDto;
    UserFullname: string;
    OrganizationUnitID: number;
    OrganizationUnit: EVA.Core.OrganizationUnitDto;
    FinancialPeriodID: number;
    FinancialPeriod: EVA.Core.FinancialPeriodDto;
    Type: EVA.Core.UserTaskTypeDto;
    Priority: number;
    IsCompleted: boolean;
    IsActive: boolean;
    CreationTime?: string;
    Deadline?: string;
    ExpectedTimeToComplete?: string;
    StartTime?: string;
    CompletionTime?: string;
    Description: string;
  }

  export interface IgnoreUserTask {
    UserTaskID: number;
  }

  /**
   * List the available UserTasks for the current user.
   * 
   * The response has a `Aggregations` property. This property contains the available filters for this set of UserTasks.
   * To apply such a filter it should added in the `Filters` property on the RequestMessage.
   * 
   * Example response:
   * ```
   * {
   * ...
   * ,
   *   "Aggregations": {
   *       "ZonedCycleCountPreCount": {
   *         "CycleCountZoneID": [
   *           {
   *             "Name": "Shelves",
   *             "Value": 10,
   *             "Count": 1
   *           },
   *           {
   *             "Name": "Stockroom",
   *             "Value": 12,
   *             "Count": 6
   *           },
   *           {
   *             "Name": "Store",
   *             "Value": 13,
   *             "Count": 4
   *           }
   *         ]
   *       }
   *     }
   *   }
   * }
   * ```
   * 
   * To apply a matching filter:
   * ```
   * {
   *   "Filters": {
   *     "ZonedCycleCountPreCount": {
   *       "CycleCountZoneID": [10]
   *     }
   *   }
   * }
   * ```
   */
  export interface ListAvailableUserTasks {
    /**
     * Return only UserTasks attached to this UserID
     */
    UserID: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted: boolean;
    /**
     * Return only UserTasks of one of the specified types
     */
    UserTaskTypes?: string[];
    /**
     * Filter for a specific UserTaskType.Name using a property name and a list of values.
     */
    Filters?: { [key: string]: { [key: string]: any[] } };
  }

  export interface ListAvailableUserTasksResponse {
    AvailableTasks: AvailableUserTaskDto[];
    Aggregations: { [key: string]: { [key: string]: UserTaskDataAggregation[] } };
    Error: EVA.Core.ServiceError;
  }

  export interface AvailableUserTaskDto {
    ID: number;
    Description: string;
    Priority: number;
    User: EVA.Core.UserDto;
    Type: EVA.Core.UserTaskTypeDto;
    CreationTime?: string;
    ExpectedTimeToComplete?: string;
    Deadline?: string;
    CanBeIgnored: boolean;
    Data: { [key: string]: any };
    /**
     * @deprecated Use the more complete `User` property, instead.
     */
    UserID: number;
    /**
     * @deprecated Use the more complete `User` property, instead.
     */
    UserFullName: string;
    /**
     * @deprecated Use the more complete `Type` property, instead.
     */
    TypeID: number;
  }

  export interface UserTaskDataAggregation {
    Name: string;
    Value: any;
    Count: number;
  }

  /**
   * Returns all of the tasks that are still active and are not complete for the current organization of the user that is
   * performing the request. `UserTaskTypes` can be used to reduce the set of tasks, by only returning the tasks with the
   * given types.
   */
  export interface ListTasksForOrganization {
    UserTaskTypes: string[];
    PageConfig?: EVA.Core.PageConfig;
  }

  export interface ListTasksForOrganizationResponse {
    Result: EVA.Core.PagedResult<EVA.Core.UserTaskDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface ListTasksThatBlockPeriodClosing {
  }

  export interface ListTasksThatBlockPeriodClosingResponse {
    Tasks: EVA.Core.UserTaskDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface ListUserTaskTypes {
  }

  export interface ListUserTaskTypesResponse {
    Types: EVA.Core.UserTaskTypeDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface PollTasks {
    UserTaskTypes: string[];
  }

  export interface PollTasksResponse {
    NumberOfTasks: number;
    Error: EVA.Core.ServiceError;
  }

  export interface SearchUserTasks {
    Start: number;
    Limit: number;
    OrganizationUnitID: number;
    Filters?: SearchUserTasksFilters;
  }

  export interface SearchUserTasksFilters {
    ShowCompleted: boolean;
  }

  export interface SearchUserTasksResponse {
    Results: EVA.Core.UserTaskDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface StartUserTask {
    UserTaskID: number;
  }

  export interface StartUserTaskResponse {
    WorkSet: UserTaskWorkSet;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateUserTask {
    ID: number;
    UserID: number;
    TypeID: number;
    Deadline?: string;
    ExpectedTimeToComplete?: string;
  }

  export interface UpdateUserTaskType {
    ID: number;
    Name?: string;
    Description?: string;
    Configuration?: string;
    DefaultPriority: number;
  }

  export interface CompleteStockReservationTask {
    Task?: StockReservationTaskDto;
    /**
     * Station to print the receipt on
     */
    StationID: number;
    /**
     * Should we print a receipt? Default true
     */
    PrintReceipt: boolean;
  }

  export interface StockReservationTaskDto {
    UserTaskID: number;
    OrderID: number;
    Order: EVA.Core.OrderDto;
    Lines: StockReservationTaskLineDto[];
  }

  export interface StockReservationTaskLineDto {
    IsCancelled: boolean;
    IsReserved: boolean;
    Barcodes: string[];
    Product: EVA.Core.ProductDto;
    ProductID: number;
    OrderLineID: number;
    QuantityOnHand: number;
    ForceComplete: boolean;
    MustBeOrdered: boolean;
    RequiredResourceTypes: EVA.Core.StockResourceTypeDto[];
    ResourceID: number;
    Resources: { [key: string]: string };
  }

  /**
   * Retrieve details on a Stock Reservation Task based on an OrderID.
   */
  export interface GetStockReservationTask {
    OrderID: number;
  }

  export interface GetStockReservationTaskResponse {
    Result: StockReservationTaskDto;
    Error: EVA.Core.ServiceError;
  }

  export interface PrintStockReservationReceipt {
    OrderID: number;
    StationID: number;
  }

  export interface StartStockReservation {
    TaskID: number;
    Force: boolean;
  }

  export interface StartStockReservationResponse {
    WorkSet: StockReservationWorkSet;
    Error: EVA.Core.ServiceError;
  }

  export interface StockReservationWorkSet {
    UserTaskID: number;
    OrderID: number;
    Order: EVA.Core.OrderDto;
    Lines: StockReservationTaskLineDto[];
  }

  /**
   * Completes a Stock Replenishment task, using the `WorkSet` returned by the `StartStockReplenishment` service.
   */
  export interface CompleteStockReplenishment {
    WorkSet?: StockReplenishmentWorkSet;
  }

  export interface StockReplenishmentWorkSet {
    Items: StockReplenishmentWorkSetItem[];
  }

  export interface StockReplenishmentWorkSetItem {
    UserTaskID: number;
    StockReplenishmentTaskID: number;
    Quantity: number;
    Type: StockReplenishmentType;
    Product: { [key: string]: any };
  }

  export const enum StockReplenishmentType {
    Default = 0,
    Priority = 1
  }

  /**
   * Creates a new Stock Replenishment task.
   */
  export interface CreateStockReplenishmentTask {
    OrganizationUnitID: number;
    ProductID: number;
    Quantity: number;
    Type: StockReplenishmentType;
  }

  /**
   * Creates new Stock Replenishment tasks in bulk, with `Products` being a key-value pair of integer product ID's and quantities.
   */
  export interface CreateStockReplenishmentTasks {
    OrganizationUnitID: number;
    Type: StockReplenishmentType;
    Products?: { [key: number]: number };
  }

  /**
   * Starts one or more Stock Replenishment tasks, returning a workset. Pass this workset to the `CompleteStockReplenishment` service when all tasks are complete.
   */
  export interface StartStockReplenishment {
    UserTaskIDs?: number[];
  }

  export interface StartStockReplenishmentResponse {
    WorkSet: StockReplenishmentWorkSet;
    Error: EVA.Core.ServiceError;
  }

  export interface CompleteReservationDeviationTask {
    WorkSet?: ReservationDeviationWorkSet;
  }

  export interface ReservationDeviationWorkSet {
    TaskID: number;
    ProductID: number;
    Orders: EVA.Core.OrderDto[];
    OrderLineIDs: number[];
    QuantityToCancel: number;
    Product: EVA.Core.ProductDto;
    QuantityToMoveToSellable: number;
    OrderLinesToCancel: OrderLineToCancel[];
    OrderLinesToOrder: OrderLineToOrder[];
    QuantityMovedBack: number;
  }

  export interface OrderLineToCancel {
    OrderLineID: number;
    QuantityToCancel: number;
  }

  export interface OrderLineToOrder {
    OrderLineID: number;
    QuantityToOrder: number;
  }

  export interface CompleteReservationDeviationTaskResponse {
    Retry: boolean;
    Error: EVA.Core.ServiceError;
  }

  export interface StartReservationDeviationTask {
    TaskID: number;
    Force: boolean;
  }

  export interface StartReservationDeviationTaskResponse {
    WorkSet: ReservationDeviationWorkSet;
    Error: EVA.Core.ServiceError;
  }

  export interface CompleteReservationCleanup {
    Task?: ReservationCleanupWorkSet;
  }

  export interface ReservationCleanupWorkSet {
    UserTaskID: number;
    ReservationCleanupTaskID: number;
    Order: EVA.Core.OrderDto;
    Lines: ReservationCleanupWorkSetOrderLine[];
  }

  export interface ReservationCleanupWorkSetOrderLine {
    QuantityToReturn: number;
    QuantityReturned: number;
    NothingToReturn: boolean;
    ReservationExpirationOverride?: string;
    OrderLine: EVA.Core.OrderLineDto;
  }

  export interface StartReservationCleanup {
    UserTaskID: number;
  }

  export interface StartReservationCleanupResponse {
    Task: ReservationCleanupWorkSet;
    Error: EVA.Core.ServiceError;
  }

  export interface StartReceiveShipment {
    UserTaskID: number;
  }

  export interface StartReceiveShipmentResponse {
    ReceiveMethod: EVA.Core.ShipmentReceiveMethods;
    IsCompleted: boolean;
    WorkSet: EVA.Core.ReceiveShipmentWorkSet;
    Error: EVA.Core.ServiceError;
  }

  export interface CompletePriceChange {
    Task?: PriceChangeWorkSet;
  }

  export interface PriceChangeWorkSet {
    UserTaskID: number;
    PriceChangeTaskID: number;
    ProductID: number;
    ProductBackendID: string;
    ProductName: string;
    OriginalPrice?: number;
    CurrentPrice?: number;
    ProductCustomID: string;
  }

  export interface StartPriceChange {
    UserTaskID: number;
  }

  export interface StartPriceChangeResponse {
    Task: PriceChangeWorkSet;
    Error: EVA.Core.ServiceError;
  }

  export interface CanProcessInitialCycleCount {
    InitialCycleCountID: number;
  }

  export interface CanProcessInitialCycleCountResponse {
    CanProcess: boolean;
    Error: EVA.Core.ServiceError;
  }

  export interface CountProductForInitialCycleCount {
    LabelID: number;
    ProductID: number;
    Quantity: number;
    Resources: { [key: string]: string };
  }

  export interface CreateInitialCycleCount {
  }

  export interface CreateInitialCycleCountResponse {
    Result: InitialCycleCountDto;
    Error: EVA.Core.ServiceError;
  }

  export interface InitialCycleCountDto {
    ID: number;
    Status: InitialCycleCountStatus;
    OrganizationUnitID: number;
  }

  export const enum InitialCycleCountStatus {
    New = 0,
    DetailCount = 1,
    Processing = 2,
    Finished = 3
  }

  export interface DeleteInitialCycleCountResult {
    ProductID: number;
    StockLabel: number;
    ResourceID: number;
    LabelID: number;
  }

  export interface GetCurrentInitialCycleCount {
  }

  export interface GetCurrentInitialCycleCountResponse {
    Result: InitialCycleCountDto;
    Error: EVA.Core.ServiceError;
  }

  export interface GetInitialCycleCountLabel {
    LabelID: number;
  }

  export interface GetInitialCycleCountLabelResponse {
    Label: InitialCycleCountLabelDto;
    Error: EVA.Core.ServiceError;
  }

  export interface InitialCycleCountLabelDto {
    ID: number;
    Number: number;
    Status: InitialCycleCountLabelStatus;
    StockLabel: number;
    ItemPreCount: number;
    ItemEndCount: number;
    CreatedByID: number;
    CreationTime?: string;
    InitialCycleCount: InitialCycleCountDto;
    PreCountedByFullName: string;
    CountedByFullName: string;
  }

  export const enum InitialCycleCountLabelStatus {
    New = 0,
    PreCounted = 1,
    Counted = 2
  }

  export interface ListInitialCycleCountLabels {
    InitialCycleCountID: number;
    Start: number;
    Limit: number;
  }

  export interface ListInitialCycleCountLabelsResponse {
    Result: InitialCycleCountLabelDto[];
    Total: number;
    Error: EVA.Core.ServiceError;
  }

  export interface ListInitialCycleCountResults {
    Start: number;
    Limit: number;
    ShowAll: boolean;
    ProductID: number;
    CustomItemNumber?: string;
    StockLabel: number;
    ResourceID: number;
    LabelID: number;
  }

  export interface ListInitialCycleCountResultsResponse {
    Results: StockWithInitialCycleCountResultDto[];
    Total: number;
    Error: EVA.Core.ServiceError;
  }

  export interface StockWithInitialCycleCountResultDto {
    ProductID: number;
    OrganizationUnitID: number;
    QuantityOnHand: number;
    StockLabelID: number;
    StockLabel: number;
    ResourceID: number;
    Quantity: number;
    BackendID: string;
    LabelID: string;
    LabelNumber: string;
    ShortDescription: string;
  }

  export interface MissingProductForInitialCycleCount {
    LabelID: number;
    Barcode?: string;
    Quantity: number;
    Photo?: number[];
    PhotoMimeType?: string;
  }

  export interface PreCountInitialCycleCountLabel {
    LabelID: number;
    Quantity: number;
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    StockLabel: number;
    StockLabelID: number;
  }

  export interface ProcessInitialCycleCountResults {
  }

  export interface ProduceInitialCycleCountLabels {
    Count: number;
    /**
     * The ID of the station, which will be used to determine what printer to use to print the bar codes
     */
    StationID: number;
    AsPDF: boolean;
    /**
     * If this is set all the labels that've currently been created will be re-generated, but no new labels will be created in the process.
     */
    ReprintLabels: boolean;
    Destination: EVA.Core.MessageTemplateDestinations;
  }

  export interface ValidatePreCount {
    LabelID: number;
    ConfirmedQuantity: number;
  }

  export interface ValidatePreCountResponse {
    Result: ValidatePreCountResults;
    Error: EVA.Core.ServiceError;
  }

  export const enum ValidatePreCountResults {
    Correct = 1,
    Deviation = 2,
    RedoDetailCount = 3
  }

  export interface CompleteCycleCount {
    WorkSet?: CycleCountWorkSet;
  }

  export interface CycleCountWorkSet {
    UserTaskID: number;
    ProductID: number;
    Product: EVA.Core.ProductDto;
    OrganizationUnitID: number;
    OrganizationUnit: EVA.Core.OrganizationUnitDto;
    RequiredResourceTypes: EVA.Core.StockResourceTypeDto[];
    StockLabels: StockLabelToCycleCount[];
  }

  export interface StockLabelToCycleCount {
    StockLabel: number;
    Lines: CycleCountWorkSetLine[];
  }

  export interface CycleCountWorkSetLine {
    CountedQuantity: number;
    Resource: ResourceToCycleCount;
    NewResources: { [key: string]: string };
  }

  export interface ResourceToCycleCount {
    ResourceID: number;
    Resources: { [key: string]: string };
  }

  export interface CompleteCycleCountResponse {
    Results: CompleteCycleCountStockLabelResult[];
    Error: EVA.Core.ServiceError;
  }

  export interface CompleteCycleCountStockLabelResult {
    OverallResult: CycleCountAttemptResult;
    StockLabel: number;
    ExpectedQuantity: number;
    CountedQuantity: number;
  }

  export const enum CycleCountAttemptResult {
    None = 0,
    CountAgain = 1,
    Finished = 2,
    FinishedWithDeviation = 3,
    CompleteResource = 5
  }

  export interface CreateManualCycleCount {
    ProductID: number;
  }

  export interface GetCycleCountDetail {
    ID: number;
  }

  export interface GetCycleCountDetailResponse {
    Result: {
      ID: number;
      StockLabel: number;
      ProductID: number;
      Product: EVA.Core.ProductDto;
      UserTaskID: number;
      UserTask: EVA.Core.UserTaskDto;
      IsCompleted: boolean;
      UserID: number;
      ResourceID: number;
      Results: CycleCountResultDto[];
      Result: CycleCountResults;
      IsActive: boolean;
      CreationTime?: string;
    };
    Error: EVA.Core.ServiceError;
  }

  export interface CycleCountResultDto {
    CycleCountID: number;
    ExpectedQuantity: number;
    CountedQuantity: number;
    ResourceID: number;
    StockLabelID: number;
    StockLabel: number;
    ID: number;
    CreatedByID: number;
    CreatedBy: EVA.Core.UserDto;
    CreationTime?: string;
    StockLabelDescription: string;
  }

  export const enum CycleCountResults {
    New = 0,
    InProgress = 1,
    Deviated = 2,
    Correct = 3,
    Unknown = 4
  }

  export interface ListCycleCounts {
    ProductID: number;
    StockLabel: number;
    ResourceID: number;
    OrganizationUnitID: number;
    BackendID?: string;
    CreatedBy?: string;
    FromDate?: string;
    ToDate?: string;
    Result: CycleCountResults;
    IsCompleted: boolean;
    PageConfig?: EVA.Core.PageConfig;
    CustomID?: string;
  }

  export interface ListCycleCountsResponse {
    CycleCounts: EVA.Core.PagedResult<{
      ID: number;
      StockLabel: number;
      ProductID: number;
      Product: EVA.Core.ProductDto;
      UserTaskID: number;
      UserTask: EVA.Core.UserTaskDto;
      IsCompleted: boolean;
      UserID: number;
      ResourceID: number;
      Results: CycleCountResultDto[];
      Result: CycleCountResults;
      IsActive: boolean;
      CreationTime?: string;
    }>;
    Error: EVA.Core.ServiceError;
  }

  export interface ListUsersWithCycleCountResults {
  }

  export interface ListUsersWithCycleCountResultsResponse {
    Users: EVA.Core.UserDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface StartCycleCount {
    TaskID: number;
  }

  export interface StartCycleCountResponse {
    WorkSet: CycleCountWorkSet;
    Error: EVA.Core.ServiceError;
  }

  /**
   * This service is used in combination with the `GetCycleCountSettings` to manage OrganizationUnit settings for CycleCounts.
   * Optionally an OrganizationUnitID can be provided, but by default the settings are updated for the current OrganizationUnit.
   * 
   * - GenerateCycleCountAfterNASC: After a NASC is created, a CycleCount will be generated
   * - MaxCycleCountsPerShop: The max number of active cyclecounts per shop
   * - MaxCycleCountsPerShopPerDay: The max number of cyclecounts to create per day per shop
   * - PastDueProductsOnly: Generate only cyclecounts for products when the interval is expired
   * - CycleCountDays: On which days cyclecounts should be generated
   * - StockLabels: Which StockLabels should be counted
   */
  export interface SetCycleCountSettings {
    OrganizationUnitID: number;
    GenerateCycleCountAfterNASC: boolean;
    MaxCycleCountsPerShop: number;
    MaxCycleCountsPerShopPerDay: number;
    PastDueProductsOnly: boolean;
    CycleCountDays: EVA.Core.DaysOfWeek;
    StockLabels?: string[];
  }

  export interface GetCycleCountSettings {
    OrganizationUnitID: number;
  }

  export interface GetCycleCountSettingsResponse {
    OrganizationUnitID: number;
    GenerateCycleCountAfterNASC: boolean;
    MaxCycleCountsPerShop: number;
    MaxCycleCountsPerShopPerDay: number;
    PastDueProductsOnly: boolean;
    CycleCountDays: EVA.Core.DaysOfWeek;
    StockLabels: string[];
    Error: EVA.Core.ServiceError;
  }

}