/* Options:
Date: 2025-12-06 13:28:23
SwiftVersion: 5.0
Version: 8.0
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://sfgboxapi.dev.scadsoftware.com

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

import Foundation
import ServiceStack

// @Route("/create-customer", "POST")
public class CreateSubscribeCustomer : IReturn, IPost, Codable
{
    public typealias Return = StripeCustomer

    public var email:String

    required public init(){}
}

public class StripeCustomer : StripeId
{
    public var accountBalance:Int
    public var businessVatId:String
    public var created:Date?
    public var defaultSource:String
    public var delinquent:Bool?
    public var Description:String
    public var discount:StripeDiscount
    public var email:String
    public var invoicePrefix:String
    public var livemode:Bool
    public var metadata:[String:String] = [:]
    public var shipping:StripeShipping
    public var sources:StripeCollection<StripeCard>
    public var subscriptions:StripeCollection<StripeSubscription>
    public var deleted:Bool
    public var currency:String

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

    private enum CodingKeys : String, CodingKey {
        case accountBalance
        case businessVatId
        case created
        case defaultSource
        case delinquent
        case Description
        case discount
        case email
        case invoicePrefix
        case livemode
        case metadata
        case shipping
        case sources
        case subscriptions
        case deleted
        case currency
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        accountBalance = try container.decodeIfPresent(Int.self, forKey: .accountBalance)
        businessVatId = try container.decodeIfPresent(String.self, forKey: .businessVatId)
        created = try container.decodeIfPresent(Date.self, forKey: .created)
        defaultSource = try container.decodeIfPresent(String.self, forKey: .defaultSource)
        delinquent = try container.decodeIfPresent(Bool.self, forKey: .delinquent)
        Description = try container.decodeIfPresent(String.self, forKey: .Description)
        discount = try container.decodeIfPresent(StripeDiscount.self, forKey: .discount)
        email = try container.decodeIfPresent(String.self, forKey: .email)
        invoicePrefix = try container.decodeIfPresent(String.self, forKey: .invoicePrefix)
        livemode = try container.decodeIfPresent(Bool.self, forKey: .livemode)
        metadata = try container.decodeIfPresent([String:String].self, forKey: .metadata) ?? [:]
        shipping = try container.decodeIfPresent(StripeShipping.self, forKey: .shipping)
        sources = try container.decodeIfPresent(StripeCollection<StripeCard>.self, forKey: .sources)
        subscriptions = try container.decodeIfPresent(StripeCollection<StripeSubscription>.self, forKey: .subscriptions)
        deleted = try container.decodeIfPresent(Bool.self, forKey: .deleted)
        currency = try container.decodeIfPresent(String.self, forKey: .currency)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if accountBalance != nil { try container.encode(accountBalance, forKey: .accountBalance) }
        if businessVatId != nil { try container.encode(businessVatId, forKey: .businessVatId) }
        if created != nil { try container.encode(created, forKey: .created) }
        if defaultSource != nil { try container.encode(defaultSource, forKey: .defaultSource) }
        if delinquent != nil { try container.encode(delinquent, forKey: .delinquent) }
        if Description != nil { try container.encode(Description, forKey: .Description) }
        if discount != nil { try container.encode(discount, forKey: .discount) }
        if email != nil { try container.encode(email, forKey: .email) }
        if invoicePrefix != nil { try container.encode(invoicePrefix, forKey: .invoicePrefix) }
        if livemode != nil { try container.encode(livemode, forKey: .livemode) }
        if metadata.count > 0 { try container.encode(metadata, forKey: .metadata) }
        if shipping != nil { try container.encode(shipping, forKey: .shipping) }
        if sources != nil { try container.encode(sources, forKey: .sources) }
        if subscriptions != nil { try container.encode(subscriptions, forKey: .subscriptions) }
        if deleted != nil { try container.encode(deleted, forKey: .deleted) }
        if currency != nil { try container.encode(currency, forKey: .currency) }
    }
}

public class StripeDiscount : StripeId
{
    public var customer:String
    public var coupon:StripeCoupon
    public var start:Date?
    public var end:Date?

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

    private enum CodingKeys : String, CodingKey {
        case customer
        case coupon
        case start
        case end
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        customer = try container.decodeIfPresent(String.self, forKey: .customer)
        coupon = try container.decodeIfPresent(StripeCoupon.self, forKey: .coupon)
        start = try container.decodeIfPresent(Date.self, forKey: .start)
        end = try container.decodeIfPresent(Date.self, forKey: .end)
    }

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

public class StripeShipping : Codable
{
    public var address:StripeAddress
    public var name:String
    public var phone:String

    required public init(){}
}

public class StripeCollection<T : Codable> : StripeId
{
    public var url:String
    public var totalCount:Int
    public var hasMore:Bool?
    public var data:[T] = []

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

    private enum CodingKeys : String, CodingKey {
        case url
        case totalCount
        case hasMore
        case data
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        url = try container.decodeIfPresent(String.self, forKey: .url)
        totalCount = try container.decodeIfPresent(Int.self, forKey: .totalCount)
        hasMore = try container.decodeIfPresent(Bool.self, forKey: .hasMore)
        data = try container.decodeIfPresent([T].self, forKey: .data) ?? []
    }

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

public class StripeCard : StripeId
{
    public var brand:String
    public var number:String
    public var last4:String
    public var dynamicLast4:String
    public var expMonth:Int
    public var expYear:Int
    public var cvc:String
    public var name:String
    public var addressCity:String
    public var addressCountry:String
    public var addressLine1:String
    public var addressLine2:String
    public var addressState:String
    public var addressZip:String
    public var cvcCheck:StripeCvcCheck?
    public var addressLine1Check:String
    public var addressZipCheck:String
    public var funding:String
    public var fingerprint:String
    public var customer:String
    public var country:String

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

    private enum CodingKeys : String, CodingKey {
        case brand
        case number
        case last4
        case dynamicLast4
        case expMonth
        case expYear
        case cvc
        case name
        case addressCity
        case addressCountry
        case addressLine1
        case addressLine2
        case addressState
        case addressZip
        case cvcCheck
        case addressLine1Check
        case addressZipCheck
        case funding
        case fingerprint
        case customer
        case country
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        brand = try container.decodeIfPresent(String.self, forKey: .brand)
        number = try container.decodeIfPresent(String.self, forKey: .number)
        last4 = try container.decodeIfPresent(String.self, forKey: .last4)
        dynamicLast4 = try container.decodeIfPresent(String.self, forKey: .dynamicLast4)
        expMonth = try container.decodeIfPresent(Int.self, forKey: .expMonth)
        expYear = try container.decodeIfPresent(Int.self, forKey: .expYear)
        cvc = try container.decodeIfPresent(String.self, forKey: .cvc)
        name = try container.decodeIfPresent(String.self, forKey: .name)
        addressCity = try container.decodeIfPresent(String.self, forKey: .addressCity)
        addressCountry = try container.decodeIfPresent(String.self, forKey: .addressCountry)
        addressLine1 = try container.decodeIfPresent(String.self, forKey: .addressLine1)
        addressLine2 = try container.decodeIfPresent(String.self, forKey: .addressLine2)
        addressState = try container.decodeIfPresent(String.self, forKey: .addressState)
        addressZip = try container.decodeIfPresent(String.self, forKey: .addressZip)
        cvcCheck = try container.decodeIfPresent(StripeCvcCheck.self, forKey: .cvcCheck)
        addressLine1Check = try container.decodeIfPresent(String.self, forKey: .addressLine1Check)
        addressZipCheck = try container.decodeIfPresent(String.self, forKey: .addressZipCheck)
        funding = try container.decodeIfPresent(String.self, forKey: .funding)
        fingerprint = try container.decodeIfPresent(String.self, forKey: .fingerprint)
        customer = try container.decodeIfPresent(String.self, forKey: .customer)
        country = try container.decodeIfPresent(String.self, forKey: .country)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if brand != nil { try container.encode(brand, forKey: .brand) }
        if number != nil { try container.encode(number, forKey: .number) }
        if last4 != nil { try container.encode(last4, forKey: .last4) }
        if dynamicLast4 != nil { try container.encode(dynamicLast4, forKey: .dynamicLast4) }
        if expMonth != nil { try container.encode(expMonth, forKey: .expMonth) }
        if expYear != nil { try container.encode(expYear, forKey: .expYear) }
        if cvc != nil { try container.encode(cvc, forKey: .cvc) }
        if name != nil { try container.encode(name, forKey: .name) }
        if addressCity != nil { try container.encode(addressCity, forKey: .addressCity) }
        if addressCountry != nil { try container.encode(addressCountry, forKey: .addressCountry) }
        if addressLine1 != nil { try container.encode(addressLine1, forKey: .addressLine1) }
        if addressLine2 != nil { try container.encode(addressLine2, forKey: .addressLine2) }
        if addressState != nil { try container.encode(addressState, forKey: .addressState) }
        if addressZip != nil { try container.encode(addressZip, forKey: .addressZip) }
        if cvcCheck != nil { try container.encode(cvcCheck, forKey: .cvcCheck) }
        if addressLine1Check != nil { try container.encode(addressLine1Check, forKey: .addressLine1Check) }
        if addressZipCheck != nil { try container.encode(addressZipCheck, forKey: .addressZipCheck) }
        if funding != nil { try container.encode(funding, forKey: .funding) }
        if fingerprint != nil { try container.encode(fingerprint, forKey: .fingerprint) }
        if customer != nil { try container.encode(customer, forKey: .customer) }
        if country != nil { try container.encode(country, forKey: .country) }
    }
}

public class StripeSubscription : StripeId
{
    public var currentPeriodEnd:Date?
    public var status:StripeSubscriptionStatus
    public var plan:StripePlan
    public var currentPeriodStart:Date?
    public var start:Date?
    public var trialStart:Date?
    public var cancelAtPeriodEnd:Bool?
    public var trialEnd:Date?
    public var canceledAt:Date?
    public var endedAt:Date?
    public var customer:String
    public var quantity:Int

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

    private enum CodingKeys : String, CodingKey {
        case currentPeriodEnd
        case status
        case plan
        case currentPeriodStart
        case start
        case trialStart
        case cancelAtPeriodEnd
        case trialEnd
        case canceledAt
        case endedAt
        case customer
        case quantity
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        currentPeriodEnd = try container.decodeIfPresent(Date.self, forKey: .currentPeriodEnd)
        status = try container.decodeIfPresent(StripeSubscriptionStatus.self, forKey: .status)
        plan = try container.decodeIfPresent(StripePlan.self, forKey: .plan)
        currentPeriodStart = try container.decodeIfPresent(Date.self, forKey: .currentPeriodStart)
        start = try container.decodeIfPresent(Date.self, forKey: .start)
        trialStart = try container.decodeIfPresent(Date.self, forKey: .trialStart)
        cancelAtPeriodEnd = try container.decodeIfPresent(Bool.self, forKey: .cancelAtPeriodEnd)
        trialEnd = try container.decodeIfPresent(Date.self, forKey: .trialEnd)
        canceledAt = try container.decodeIfPresent(Date.self, forKey: .canceledAt)
        endedAt = try container.decodeIfPresent(Date.self, forKey: .endedAt)
        customer = try container.decodeIfPresent(String.self, forKey: .customer)
        quantity = try container.decodeIfPresent(Int.self, forKey: .quantity)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if currentPeriodEnd != nil { try container.encode(currentPeriodEnd, forKey: .currentPeriodEnd) }
        if status != nil { try container.encode(status, forKey: .status) }
        if plan != nil { try container.encode(plan, forKey: .plan) }
        if currentPeriodStart != nil { try container.encode(currentPeriodStart, forKey: .currentPeriodStart) }
        if start != nil { try container.encode(start, forKey: .start) }
        if trialStart != nil { try container.encode(trialStart, forKey: .trialStart) }
        if cancelAtPeriodEnd != nil { try container.encode(cancelAtPeriodEnd, forKey: .cancelAtPeriodEnd) }
        if trialEnd != nil { try container.encode(trialEnd, forKey: .trialEnd) }
        if canceledAt != nil { try container.encode(canceledAt, forKey: .canceledAt) }
        if endedAt != nil { try container.encode(endedAt, forKey: .endedAt) }
        if customer != nil { try container.encode(customer, forKey: .customer) }
        if quantity != nil { try container.encode(quantity, forKey: .quantity) }
    }
}

public enum StripeType : String, Codable
{
    case unknown
    case account
    case card
    case charge
    case coupon
    case customer
    case discount
    case dispute
    case event
    case invoiceitem
    case invoice
    case line_item
    case plan
    case subscription
    case token
    case transfer
    case list
    case product
}

public class StripeId : StripeObject
{
    public var id:String

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

    private enum CodingKeys : String, CodingKey {
        case id
    }

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

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

public class StripeCoupon : StripeId
{
    public var amountOff:Int?
    public var created:Date?
    public var currency:String
    public var duration:StripeCouponDuration
    public var durationInMonths:Int?
    public var livemode:Bool
    public var maxRedemptions:Int?
    public var metadata:[String:String] = [:]
    public var percentOff:Int?
    public var redeemBy:Date?
    public var timesRedeemed:Int
    public var valid:Bool

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

    private enum CodingKeys : String, CodingKey {
        case amountOff
        case created
        case currency
        case duration
        case durationInMonths
        case livemode
        case maxRedemptions
        case metadata
        case percentOff
        case redeemBy
        case timesRedeemed
        case valid
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        amountOff = try container.decodeIfPresent(Int.self, forKey: .amountOff)
        created = try container.decodeIfPresent(Date.self, forKey: .created)
        currency = try container.decodeIfPresent(String.self, forKey: .currency)
        duration = try container.decodeIfPresent(StripeCouponDuration.self, forKey: .duration)
        durationInMonths = try container.decodeIfPresent(Int.self, forKey: .durationInMonths)
        livemode = try container.decodeIfPresent(Bool.self, forKey: .livemode)
        maxRedemptions = try container.decodeIfPresent(Int.self, forKey: .maxRedemptions)
        metadata = try container.decodeIfPresent([String:String].self, forKey: .metadata) ?? [:]
        percentOff = try container.decodeIfPresent(Int.self, forKey: .percentOff)
        redeemBy = try container.decodeIfPresent(Date.self, forKey: .redeemBy)
        timesRedeemed = try container.decodeIfPresent(Int.self, forKey: .timesRedeemed)
        valid = try container.decodeIfPresent(Bool.self, forKey: .valid)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if amountOff != nil { try container.encode(amountOff, forKey: .amountOff) }
        if created != nil { try container.encode(created, forKey: .created) }
        if currency != nil { try container.encode(currency, forKey: .currency) }
        if duration != nil { try container.encode(duration, forKey: .duration) }
        if durationInMonths != nil { try container.encode(durationInMonths, forKey: .durationInMonths) }
        if livemode != nil { try container.encode(livemode, forKey: .livemode) }
        if maxRedemptions != nil { try container.encode(maxRedemptions, forKey: .maxRedemptions) }
        if metadata.count > 0 { try container.encode(metadata, forKey: .metadata) }
        if percentOff != nil { try container.encode(percentOff, forKey: .percentOff) }
        if redeemBy != nil { try container.encode(redeemBy, forKey: .redeemBy) }
        if timesRedeemed != nil { try container.encode(timesRedeemed, forKey: .timesRedeemed) }
        if valid != nil { try container.encode(valid, forKey: .valid) }
    }
}

public class StripeAddress : Codable
{
    public var city:String
    public var country:String
    public var line1:String
    public var line2:String
    public var postalCode:String
    public var state:String

    required public init(){}
}

public enum StripeCvcCheck : String, Codable
{
    case Unknown
    case Pass
    case Fail
    case Unchecked
}

public enum StripeSubscriptionStatus : String, Codable
{
    case Unknown
    case Trialing
    case Active
    case PastDue
    case Canceled
    case Unpaid
}

public class StripePlan : StripeId
{
    public var amount:Int
    public var created:Date?
    public var currency:String
    public var interval:StripePlanInterval
    public var intervalCount:Int?
    public var livemode:Bool
    public var metadata:[String:String] = [:]
    public var nickname:String
    public var product:String
    public var trialPeriodDays:Int?

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

    private enum CodingKeys : String, CodingKey {
        case amount
        case created
        case currency
        case interval
        case intervalCount
        case livemode
        case metadata
        case nickname
        case product
        case trialPeriodDays
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        amount = try container.decodeIfPresent(Int.self, forKey: .amount)
        created = try container.decodeIfPresent(Date.self, forKey: .created)
        currency = try container.decodeIfPresent(String.self, forKey: .currency)
        interval = try container.decodeIfPresent(StripePlanInterval.self, forKey: .interval)
        intervalCount = try container.decodeIfPresent(Int.self, forKey: .intervalCount)
        livemode = try container.decodeIfPresent(Bool.self, forKey: .livemode)
        metadata = try container.decodeIfPresent([String:String].self, forKey: .metadata) ?? [:]
        nickname = try container.decodeIfPresent(String.self, forKey: .nickname)
        product = try container.decodeIfPresent(String.self, forKey: .product)
        trialPeriodDays = try container.decodeIfPresent(Int.self, forKey: .trialPeriodDays)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if amount != nil { try container.encode(amount, forKey: .amount) }
        if created != nil { try container.encode(created, forKey: .created) }
        if currency != nil { try container.encode(currency, forKey: .currency) }
        if interval != nil { try container.encode(interval, forKey: .interval) }
        if intervalCount != nil { try container.encode(intervalCount, forKey: .intervalCount) }
        if livemode != nil { try container.encode(livemode, forKey: .livemode) }
        if metadata.count > 0 { try container.encode(metadata, forKey: .metadata) }
        if nickname != nil { try container.encode(nickname, forKey: .nickname) }
        if product != nil { try container.encode(product, forKey: .product) }
        if trialPeriodDays != nil { try container.encode(trialPeriodDays, forKey: .trialPeriodDays) }
    }
}

public class StripeObject : Codable
{
    public var object:StripeType?

    required public init(){}
}

public enum StripeCouponDuration : String, Codable
{
    case forever
    case once
    case repeating
}

public enum StripePlanInterval : String, Codable
{
    case month
    case year
}