/* Options:
Date: 2025-05-10 02:54:39
SwiftVersion: 5.0
Version: 8.40
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://active-ewebservice.biz/aeservices30/api

//BaseClass: 
//AddModelExtensions: True
//AddServiceStackTypes: True
IncludeTypes: InventoryHistoryRequest.*
//ExcludeTypes: 
//ExcludeGenericBaseTypes: False
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
//InitializeCollections: True
//TreatTypesAsStrings: 
//DefaultImports: Foundation,ServiceStack
*/

import Foundation
import ServiceStack

/**
* InventoryHistoryRequires active-e Inventory Service
*/
// @Route("/InventoryHistory", "GET")
// @DataContract
public class InventoryHistoryRequest : BaseSecureRequest, IReturn
{
    public typealias Return = InventoryHistoryResponse

    // @DataMember
    public var locId:Int?

    // @DataMember
    public var item:String

    required public init(){ super.init() }

    private enum CodingKeys : String, CodingKey {
        case locId
        case item
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        locId = try container.decodeIfPresent(Int.self, forKey: .locId)
        item = try container.decodeIfPresent(String.self, forKey: .item)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if locId != nil { try container.encode(locId, forKey: .locId) }
        if item != nil { try container.encode(item, forKey: .item) }
    }
}

// @DataContract
public class InventoryHistoryResponse : BaseResponse
{
    // @DataMember
    // @ApiMember(Name="HistoryRecords", ParameterType="body")
    public var historyRecords:[InventoryHistoryObj] = []

    // @DataMember
    // @ApiMember(Name="InventoryDetail", ParameterType="body")
    public var inventoryDetail:InventoryDetailResponse

    required public init(){ super.init() }

    private enum CodingKeys : String, CodingKey {
        case historyRecords
        case inventoryDetail
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        historyRecords = try container.decodeIfPresent([InventoryHistoryObj].self, forKey: .historyRecords) ?? []
        inventoryDetail = try container.decodeIfPresent(InventoryDetailResponse.self, forKey: .inventoryDetail)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if historyRecords.count > 0 { try container.encode(historyRecords, forKey: .historyRecords) }
        if inventoryDetail != nil { try container.encode(inventoryDetail, forKey: .inventoryDetail) }
    }
}

// @DataContract
public class BaseRequest : Codable
{
    /**
    * This is your AIM API Key provided by Tri-Tech
    */
    // @DataMember
    // @ApiMember(DataType="string", Description="This is your AIM API Key provided by Tri-Tech", IsRequired=true, Name="ApiKey", ParameterType="header")
    public var apiKey:String

    // @DataMember
    // @ApiMember(DataType="string", Name="OAuthToken", ParameterType="header")
    public var oAuthToken:String

    required public init(){}
}

// @DataContract
public class BaseSecureRequest : BaseRequest
{
    /**
    * 
    */
    // @DataMember
    // @ApiMember(DataType="string", Description="", Name="Token", ParameterType="Header")
    public var token:String

    /**
    * 
    */
    // @DataMember
    // @ApiMember(DataType="string", Description="", Name="DeviceId", ParameterType="Header")
    public var deviceId:String

    /**
    * 
    */
    // @DataMember
    // @ApiMember(DataType="string", Description="", IsRequired=true, Name="AppId", ParameterType="Header")
    public var appId:String

    required public init(){ super.init() }

    private enum CodingKeys : String, CodingKey {
        case token
        case deviceId
        case appId
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        token = try container.decodeIfPresent(String.self, forKey: .token)
        deviceId = try container.decodeIfPresent(String.self, forKey: .deviceId)
        appId = try container.decodeIfPresent(String.self, forKey: .appId)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if token != nil { try container.encode(token, forKey: .token) }
        if deviceId != nil { try container.encode(deviceId, forKey: .deviceId) }
        if appId != nil { try container.encode(appId, forKey: .appId) }
    }
}

// @DataContract
public class InventoryHistoryObj : Codable
{
    // @DataMember
    public var dateVal:Date

    // @DataMember
    public var sDateVal:Date

    // @DataMember
    public var acct:Int

    // @DataMember
    public var sub:Int

    // @DataMember
    public var cusName:String

    // @DataMember
    public var qty:Double

    // @DataMember
    public var amt:Double

    // @DataMember
    public var ref:String

    // @DataMember
    public var type:String

    // @DataMember
    public var serial:String

    // @DataMember
    public var employee:String

    // @DataMember
    public var employeeName:String

    // @DataMember
    public var stloc:String

    // @DataMember
    public var dunn:String

    // @DataMember
    public var soldDesc:String

    // @DataMember
    public var tcp_rtncode:String

    // @DataMember
    public var tableName:String

    // @DataMember
    public var traPk:Int?

    // @DataMember
    public var cusPk:Int?

    // @DataMember
    public var sasPk:Int?

    // @DataMember
    public var saqPk:Int?

    // @DataMember
    public var skuPk:Int?

    // @DataMember
    public var sadPk:Int?

    // @DataMember
    public var tablePk:Int

    // @DataMember
    public var Description:String

    required public init(){}
}

// @DataContract
public class InventoryDetailResponse : BaseResponse
{
    // @DataMember
    public var sadPk:Int

    // @DataMember
    public var invType:String

    // @DataMember
    public var model:String

    // @DataMember
    public var Description:String

    // @DataMember
    public var mfg:String

    // @DataMember
    public var category:Int

    // @DataMember
    public var categoryDescription:String

    // @DataMember
    public var subCategory:Int

    // @DataMember
    public var subCategoryDescription:String

    // @DataMember
    public var selectionCode:String

    // @DataMember
    public var selectionCodeDescription:String

    // @DataMember
    public var sellSerialsOnline:Bool

    // @DataMember
    public var notes:String

    // @DataMember
    public var images:[ImageInfo] = []

    // @DataMember
    public var hasImages:Bool

    // @DataMember
    public var variantDetails:[InventoryDetailByVariant] = []

    // @DataMember
    public var addOns:[AddOnDetail] = []

    // @DataMember
    public var activeEInfo:ActiveEInfo

    // @DataMember
    public var weight:Double

    // @DataMember
    public var unit:String

    // @DataMember
    public var shipCharge:Double

    required public init(){ super.init() }

    private enum CodingKeys : String, CodingKey {
        case sadPk
        case invType
        case model
        case Description
        case mfg
        case category
        case categoryDescription
        case subCategory
        case subCategoryDescription
        case selectionCode
        case selectionCodeDescription
        case sellSerialsOnline
        case notes
        case images
        case hasImages
        case variantDetails
        case addOns
        case activeEInfo
        case weight
        case unit
        case shipCharge
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        sadPk = try container.decodeIfPresent(Int.self, forKey: .sadPk)
        invType = try container.decodeIfPresent(String.self, forKey: .invType)
        model = try container.decodeIfPresent(String.self, forKey: .model)
        Description = try container.decodeIfPresent(String.self, forKey: .Description)
        mfg = try container.decodeIfPresent(String.self, forKey: .mfg)
        category = try container.decodeIfPresent(Int.self, forKey: .category)
        categoryDescription = try container.decodeIfPresent(String.self, forKey: .categoryDescription)
        subCategory = try container.decodeIfPresent(Int.self, forKey: .subCategory)
        subCategoryDescription = try container.decodeIfPresent(String.self, forKey: .subCategoryDescription)
        selectionCode = try container.decodeIfPresent(String.self, forKey: .selectionCode)
        selectionCodeDescription = try container.decodeIfPresent(String.self, forKey: .selectionCodeDescription)
        sellSerialsOnline = try container.decodeIfPresent(Bool.self, forKey: .sellSerialsOnline)
        notes = try container.decodeIfPresent(String.self, forKey: .notes)
        images = try container.decodeIfPresent([ImageInfo].self, forKey: .images) ?? []
        hasImages = try container.decodeIfPresent(Bool.self, forKey: .hasImages)
        variantDetails = try container.decodeIfPresent([InventoryDetailByVariant].self, forKey: .variantDetails) ?? []
        addOns = try container.decodeIfPresent([AddOnDetail].self, forKey: .addOns) ?? []
        activeEInfo = try container.decodeIfPresent(ActiveEInfo.self, forKey: .activeEInfo)
        weight = try container.decodeIfPresent(Double.self, forKey: .weight)
        unit = try container.decodeIfPresent(String.self, forKey: .unit)
        shipCharge = try container.decodeIfPresent(Double.self, forKey: .shipCharge)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if sadPk != nil { try container.encode(sadPk, forKey: .sadPk) }
        if invType != nil { try container.encode(invType, forKey: .invType) }
        if model != nil { try container.encode(model, forKey: .model) }
        if Description != nil { try container.encode(Description, forKey: .Description) }
        if mfg != nil { try container.encode(mfg, forKey: .mfg) }
        if category != nil { try container.encode(category, forKey: .category) }
        if categoryDescription != nil { try container.encode(categoryDescription, forKey: .categoryDescription) }
        if subCategory != nil { try container.encode(subCategory, forKey: .subCategory) }
        if subCategoryDescription != nil { try container.encode(subCategoryDescription, forKey: .subCategoryDescription) }
        if selectionCode != nil { try container.encode(selectionCode, forKey: .selectionCode) }
        if selectionCodeDescription != nil { try container.encode(selectionCodeDescription, forKey: .selectionCodeDescription) }
        if sellSerialsOnline != nil { try container.encode(sellSerialsOnline, forKey: .sellSerialsOnline) }
        if notes != nil { try container.encode(notes, forKey: .notes) }
        if images.count > 0 { try container.encode(images, forKey: .images) }
        if hasImages != nil { try container.encode(hasImages, forKey: .hasImages) }
        if variantDetails.count > 0 { try container.encode(variantDetails, forKey: .variantDetails) }
        if addOns.count > 0 { try container.encode(addOns, forKey: .addOns) }
        if activeEInfo != nil { try container.encode(activeEInfo, forKey: .activeEInfo) }
        if weight != nil { try container.encode(weight, forKey: .weight) }
        if unit != nil { try container.encode(unit, forKey: .unit) }
        if shipCharge != nil { try container.encode(shipCharge, forKey: .shipCharge) }
    }
}

// @DataContract
public class BaseResponse : Codable
{
    /**
    * 
    */
    // @DataMember
    // @ApiMember(DataType="BaseResponseResult", Description="", Name="Status", ParameterType="body")
    public var status:BaseResponseResult

    required public init(){}
}