import Foundation
import azureSwiftRuntime
// Put200Acceptedcanceled200 long running put request, service returns a 201 to the initial request, with an entity
// that contains ProvisioningState=â€™Creatingâ€™.  Polls return this value until the last poll returns a â€˜200â€™ with
// ProvisioningState=â€™Canceledâ€™ This method may poll for completion. Polling can be canceled by passing the cancel
// channel argument. The channel will be used to cancel polling and any outstanding HTTP requests.
class LROsPut200Acceptedcanceled200Command : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/put/200/accepted/canceled/200"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// Put200Succeeded long running put request, service returns a 200 to the initial request, with an entity that contains
// ProvisioningState=â€™Succeededâ€™. This method may poll for completion. Polling can be canceled by passing the cancel
// channel argument. The channel will be used to cancel polling and any outstanding HTTP requests.
class LROsPut200SucceededCommand : BaseCommand {

    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/put/200/succeeded"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// Put200SucceededNoState long running put request, service returns a 200 to the initial request, with an entity that
// does not contain ProvisioningState=â€™Succeededâ€™. This method may poll for completion. Polling can be canceled by
// passing the cancel channel argument. The channel will be used to cancel polling and any outstanding HTTP requests.
class LROsPut200SucceededNoStateCommand : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/put/200/succeeded/nostate"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// Put200UpdatingSucceeded204 long running put request, service returns a 201 to the initial request, with an entity
// that contains ProvisioningState=â€™Updatingâ€™.  Polls return this value until the last poll returns a â€˜200â€™ with
// ProvisioningState=â€™Succeededâ€™ This method may poll for completion. Polling can be canceled by passing the cancel
// channel argument. The channel will be used to cancel polling and any outstanding HTTP requests.
class LROsPut200UpdatingSucceeded204Command : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/put/200/updating/succeeded/200"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// Put201CreatingFailed200 long running put request, service returns a 201 to the initial request, with an entity that
// contains ProvisioningState=â€™Createdâ€™.  Polls return this value until the last poll returns a â€˜200â€™ with
// ProvisioningState=â€™Failedâ€™ This method may poll for completion. Polling can be canceled by passing the cancel
// channel argument. The channel will be used to cancel polling and any outstanding HTTP requests.
class LROsPut201CreatingFailed200Command : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/put/201/created/failed/200"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// Put201CreatingSucceeded200 long running put request, service returns a 201 to the initial request, with an entity
// that contains ProvisioningState=â€™Creatingâ€™.  Polls return this value until the last poll returns a â€˜200â€™ with
// ProvisioningState=â€™Succeededâ€™ This method may poll for completion. Polling can be canceled by passing the cancel
// channel argument. The channel will be used to cancel polling and any outstanding HTTP requests.
class LROsPut201CreatingSucceeded200Command : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/put/201/creating/succeeded/200"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// Put202Retry200 long running put request, service returns a 202 to the initial request, with a location header that
// points to a polling URL that returns a 200 and an entity that doesn't contains ProvisioningState This method may
// poll for completion. Polling can be canceled by passing the cancel channel argument. The channel will be used to
// cancel polling and any outstanding HTTP requests.
class LROsPut202Retry200Command : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/put/202/retry/200"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    // non-blocking
    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// PutAsyncNoHeaderInRetry long running put request, service returns a 202 to the initial request with
// azureAsyncOperation header. Subsequent calls to operation status do not contain azureAsyncOperation header. This
// method may poll for completion. Polling can be canceled by passing the cancel channel argument. The channel will be
// used to cancel polling and any outstanding HTTP requests.
class LROsPutAsyncNoHeaderInRetryCommand : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/putasync/noheader/201/200"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
import RxSwift

// PutAsyncNonResource long running put request with non resource. This method may poll for completion. Polling can be
// canceled by passing the cancel channel argument. The channel will be used to cancel polling and any outstanding HTTP
// requests.
class LROsPutAsyncNonResourceCommand : BaseCommand {
    var sku :  SkuTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/putnonresourceasync/202/200"
    }

    override func preCall()  {
        self.body = sku
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(sku as! SkuType?)
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(SkuType?.self, from: data)
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (SkuTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: SkuType?, error: Error?)  in
            completionHandler(result, error)
        }
    }

}


import Foundation
import azureSwiftRuntime
// PutAsyncNoRetrycanceled long running put request, service returns a 200 to the initial request, with an entity that
// contains ProvisioningState=â€™Creatingâ€™. Poll the endpoint indicated in the azureAsyncOperation header for operation
// status This method may poll for completion. Polling can be canceled by passing the cancel channel argument. The
// channel will be used to cancel polling and any outstanding HTTP requests.
class LROsPutAsyncNoRetrycanceledCommand : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/putasync/noretry/canceled"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// PutAsyncNoRetrySucceeded long running put request, service returns a 200 to the initial request, with an entity that
// contains ProvisioningState=â€™Creatingâ€™. Poll the endpoint indicated in the azureAsyncOperation header for operation
// status This method may poll for completion. Polling can be canceled by passing the cancel channel argument. The
// channel will be used to cancel polling and any outstanding HTTP requests.
class LROsPutAsyncNoRetrySucceededCommand : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/putasync/noretry/succeeded"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// PutAsyncRetryFailed long running put request, service returns a 200 to the initial request, with an entity that
// contains ProvisioningState=â€™Creatingâ€™. Poll the endpoint indicated in the azureAsyncOperation header for operation
// status This method may poll for completion. Polling can be canceled by passing the cancel channel argument. The
// channel will be used to cancel polling and any outstanding HTTP requests.
class LROsPutAsyncRetryFailedCommand : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/putasync/retry/failed"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// PutAsyncRetrySucceeded long running put request, service returns a 200 to the initial request, with an entity that
// contains ProvisioningState=â€™Creatingâ€™. Poll the endpoint indicated in the azureAsyncOperation header for operation
// status This method may poll for completion. Polling can be canceled by passing the cancel channel argument. The
// channel will be used to cancel polling and any outstanding HTTP requests.
class LROsPutAsyncRetrySucceededCommand : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/putasync/retry/succeeded"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// PutAsyncSubResource long running put request with sub resource. This method may poll for completion. Polling can be
// canceled by passing the cancel channel argument. The channel will be used to cancel polling and any outstanding HTTP
// requests.
class LROsPutAsyncSubResourceCommand : BaseCommand {
    var product :  SubProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/putsubresourceasync/202/200"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! SubProductType?)
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(SubProductType?.self, from: data)
    }

    public func execute(client: RuntimeClient) throws -> SubProductTypeProtocol? {
        return try client.execute(command: self) as! SubProductTypeProtocol?
    }

   public func executeAsync(client: RuntimeClient, completionHandler: @escaping (SubProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: SubProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// PutNoHeaderInRetry long running put request, service returns a 202 to the initial request with location header.
// Subsequent calls to operation status do not contain location header. This method may poll for completion. Polling
// can be canceled by passing the cancel channel argument. The channel will be used to cancel polling and any
// outstanding HTTP requests.
class LROsPutNoHeaderInRetryCommand : BaseCommand {
    var product :  ProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/put/noheader/202/200"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! ProductType?)
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(ProductType?.self, from: data)
    }

    public func execute(client: RuntimeClient) throws -> ProductTypeProtocol? {
        return try client.execute(command: self) as! ProductTypeProtocol?
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (ProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: ProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// PutNonResource long running put request with non resource. This method may poll for completion. Polling can be
// canceled by passing the cancel channel argument. The channel will be used to cancel polling and any outstanding HTTP
// requests.
class LROsPutNonResourceCommand : BaseCommand {
    var sku :  SkuTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/putnonresource/202/200"
    }

    override func preCall()  {
        self.body = sku
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(sku as! SkuType?)
    }

    public func execute(client: RuntimeClient) throws -> SkuTypeProtocol? {
        return try client.execute(command: self) as! SkuTypeProtocol?
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(SkuType?.self, from: data)
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (SkuTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: SkuType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
import azureSwiftRuntime
// PutSubResource long running put request with sub resource. This method may poll for completion. Polling can be
// canceled by passing the cancel channel argument. The channel will be used to cancel polling and any outstanding HTTP
// requests.
class LROsPutSubResourceCommand : BaseCommand {
    var product :  SubProductTypeProtocol?

    override init() {
        super.init()
        self.method = "Put"
        self.isLongRunningOperation = true
        self.path = "/lro/putsubresource/202/200"
    }

    override func preCall()  {
        self.body = product
    }

    override func encodeBody() throws -> Data? {
        return try CoderFactory.encoder(for: .json).encode(product as! SubProductType?)
    }

    public func execute(client: RuntimeClient) throws -> SubProductTypeProtocol? {
        return try client.execute(command: self) as! SubProductTypeProtocol?
    }

    override func returnFunc(data: Data) throws -> Decodable? {
        return try CoderFactory.decoder(for: .json).decode(SubProductType?.self, from: data)
    }

    public func executeAsync(client: RuntimeClient, completionHandler: @escaping (SubProductTypeProtocol?, Error?) -> Void) {
        client.executeAsyncLRO (command: self) {
            (result: SubProductType?, error: Error?)  in
            completionHandler(result, error)
        }
    }
}


import Foundation
public struct CloudErrorType : CloudErrorTypeProtocol {
    public var status: Int32?
    public var message: String?

    enum CodingKeys: String, CodingKey {
        case status = "status"
        case message = "message"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.status) {
        status = try container.decode(Int32?.self, forKey: .status)
    }
    if container.contains(.message) {
        message = try container.decode(String?.self, forKey: .message)
    }
  }

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


import Foundation
public struct LRORetrysDelete202Retry200Headers : LRORetrysDelete202Retry200HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LRORetrysDeleteAsyncRelativeRetrySucceededHeaders : LRORetrysDeleteAsyncRelativeRetrySucceededHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LRORetrysDeleteProvisioning202Accepted200SucceededHeaders : LRORetrysDeleteProvisioning202Accepted200SucceededHeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LRORetrysPost202Retry200Headers : LRORetrysPost202Retry200HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LRORetrysPostAsyncRelativeRetrySucceededHeaders : LRORetrysPostAsyncRelativeRetrySucceededHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LRORetrysPutAsyncRelativeRetrySucceededHeaders : LRORetrysPutAsyncRelativeRetrySucceededHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsDelete202NonRetry400Headers : LROSADsDelete202NonRetry400HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsDelete202RetryInvalidHeaderHeaders : LROSADsDelete202RetryInvalidHeaderHeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsDeleteAsyncRelativeRetry400Headers : LROSADsDeleteAsyncRelativeRetry400HeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsDeleteAsyncRelativeRetryInvalidHeaderHeaders : LROSADsDeleteAsyncRelativeRetryInvalidHeaderHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsDeleteAsyncRelativeRetryInvalidJsonPollingHeaders : LROSADsDeleteAsyncRelativeRetryInvalidJsonPollingHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsDeleteAsyncRelativeRetryNoStatusHeaders : LROSADsDeleteAsyncRelativeRetryNoStatusHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsDeleteNonRetry400Headers : LROSADsDeleteNonRetry400HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPost202NoLocationHeaders : LROSADsPost202NoLocationHeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPost202NonRetry400Headers : LROSADsPost202NonRetry400HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPost202RetryInvalidHeaderHeaders : LROSADsPost202RetryInvalidHeaderHeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPostAsyncRelativeRetry400Headers : LROSADsPostAsyncRelativeRetry400HeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPostAsyncRelativeRetryInvalidHeaderHeaders : LROSADsPostAsyncRelativeRetryInvalidHeaderHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPostAsyncRelativeRetryInvalidJsonPollingHeaders : LROSADsPostAsyncRelativeRetryInvalidJsonPollingHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPostAsyncRelativeRetryNoPayloadHeaders : LROSADsPostAsyncRelativeRetryNoPayloadHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPostNonRetry400Headers : LROSADsPostNonRetry400HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPutAsyncRelativeRetry400Headers : LROSADsPutAsyncRelativeRetry400HeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPutAsyncRelativeRetryInvalidHeaderHeaders : LROSADsPutAsyncRelativeRetryInvalidHeaderHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPutAsyncRelativeRetryInvalidJsonPollingHeaders : LROSADsPutAsyncRelativeRetryInvalidJsonPollingHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPutAsyncRelativeRetryNoStatusHeaders : LROSADsPutAsyncRelativeRetryNoStatusHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROSADsPutAsyncRelativeRetryNoStatusPayloadHeaders : LROSADsPutAsyncRelativeRetryNoStatusPayloadHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsCustomHeaderPost202Retry200Headers : LROsCustomHeaderPost202Retry200HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsCustomHeaderPostAsyncRetrySucceededHeaders : LROsCustomHeaderPostAsyncRetrySucceededHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsCustomHeaderPutAsyncRetrySucceededHeaders : LROsCustomHeaderPutAsyncRetrySucceededHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsDelete202NoRetry204Headers : LROsDelete202NoRetry204HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsDelete202Retry200Headers : LROsDelete202Retry200HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsDeleteAsyncNoHeaderInRetryHeaders : LROsDeleteAsyncNoHeaderInRetryHeadersProtocol {
    public var Location: String?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
  }

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


import Foundation
public struct LROsDeleteAsyncNoRetrySucceededHeaders : LROsDeleteAsyncNoRetrySucceededHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsDeleteAsyncRetrycanceledHeaders : LROsDeleteAsyncRetrycanceledHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsDeleteAsyncRetryFailedHeaders : LROsDeleteAsyncRetryFailedHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsDeleteAsyncRetrySucceededHeaders : LROsDeleteAsyncRetrySucceededHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsDeleteNoHeaderInRetryHeaders : LROsDeleteNoHeaderInRetryHeadersProtocol {
    public var Location: String?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
  }

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


import Foundation
public struct LROsDeleteProvisioning202Accepted200SucceededHeaders : LROsDeleteProvisioning202Accepted200SucceededHeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsDeleteProvisioning202Deletingcanceled200Headers : LROsDeleteProvisioning202Deletingcanceled200HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsDeleteProvisioning202DeletingFailed200Headers : LROsDeleteProvisioning202DeletingFailed200HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsPost202NoRetry204Headers : LROsPost202NoRetry204HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsPost202Retry200Headers : LROsPost202Retry200HeadersProtocol {
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsPostAsyncNoRetrySucceededHeaders : LROsPostAsyncNoRetrySucceededHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsPostAsyncRetrycanceledHeaders : LROsPostAsyncRetrycanceledHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsPostAsyncRetryFailedHeaders : LROsPostAsyncRetryFailedHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsPostAsyncRetrySucceededHeaders : LROsPostAsyncRetrySucceededHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsPutAsyncNoHeaderInRetryHeaders : LROsPutAsyncNoHeaderInRetryHeadersProtocol {
    public var azureAsyncOperation: String?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
  }

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


import Foundation
public struct LROsPutAsyncNoRetrycanceledHeaders : LROsPutAsyncNoRetrycanceledHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
  }

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


import Foundation
public struct LROsPutAsyncNoRetrySucceededHeaders : LROsPutAsyncNoRetrySucceededHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
  }

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


import Foundation
public struct LROsPutAsyncRetryFailedHeaders : LROsPutAsyncRetryFailedHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsPutAsyncRetrySucceededHeaders : LROsPutAsyncRetrySucceededHeadersProtocol {
    public var azureAsyncOperation: String?
    public var Location: String?
    public var retryAfter: Int32?

    enum CodingKeys: String, CodingKey {
        case azureAsyncOperation = "Azure-AsyncOperation"
        case Location = "Location"
        case retryAfter = "Retry-After"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.azureAsyncOperation) {
        azureAsyncOperation = try container.decode(String?.self, forKey: .azureAsyncOperation)
    }
    if container.contains(.Location) {
        Location = try container.decode(String?.self, forKey: .Location)
    }
    if container.contains(.retryAfter) {
        retryAfter = try container.decode(Int32?.self, forKey: .retryAfter)
    }
  }

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


import Foundation
public struct LROsPutNoHeaderInRetryHeaders : LROsPutNoHeaderInRetryHeadersProtocol {
    public var location: String?

    enum CodingKeys: String, CodingKey {
        case location = "location"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.location) {
        location = try container.decode(String?.self, forKey: .location)
    }
  }

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


import Foundation
public struct OperationResultErrorType : OperationResultErrorTypeProtocol {
    public var code: Int32?
    public var message: String?

    enum CodingKeys: String, CodingKey {
        case code = "code"
        case message = "message"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.code) {
        code = try container.decode(Int32?.self, forKey: .code)
    }
    if container.contains(.message) {
        message = try container.decode(String?.self, forKey: .message)
    }
  }

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


import Foundation
public struct OperationResultType : OperationResultTypeProtocol {
    public var status: Status?
    public var error: OperationResultErrorTypeProtocol?

    enum CodingKeys: String, CodingKey {
        case status = "status"
        case error = "error"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.status) {
        status = try container.decode(Status?.self, forKey: .status)
    }
    if container.contains(.error) {
        error = try container.decode(OperationResultErrorType?.self, forKey: .error)
    }
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    if self.status != nil {try container.encode(status, forKey: .status)}
    if self.error != nil {try container.encode(error as! OperationResultErrorType?, forKey: .error)}
  }
}


import Foundation
public struct ProductPropertiesType : ProductPropertiesTypeProtocol {
    public var provisioningState: String?
    public var provisioningStateValues: ProvisioningStateValues?

    enum CodingKeys: String, CodingKey {
        case provisioningState = "provisioningState"
        case provisioningStateValues = "provisioningStateValues"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.provisioningState) {
        provisioningState = try container.decode(String?.self, forKey: .provisioningState)
    }
    if container.contains(.provisioningStateValues) {
        provisioningStateValues = try container.decode(ProvisioningStateValues?.self, forKey: .provisioningStateValues)
    }
  }

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


import Foundation
public struct ProductType : ProductTypeProtocol, ResourceTypeProtocol {
    public var id: String?
    public var type: String?
    public var tags: [String:String?]?
    public var location: String?
    public var name: String?
    public var properties: ProductPropertiesTypeProtocol?

    enum CodingKeys: String, CodingKey {
        case id = "id"
        case type = "type"
        case tags = "tags"
        case location = "location"
        case name = "name"
        case properties = "properties"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.id) {
        id = try container.decode(String?.self, forKey: .id)
    }
    if container.contains(.type) {
        type = try container.decode(String?.self, forKey: .type)
    }
    if container.contains(.tags) {
        tags = try container.decode([String:String?]?.self, forKey: .tags)
    }
    if container.contains(.location) {
        location = try container.decode(String?.self, forKey: .location)
    }
    if container.contains(.name) {
        name = try container.decode(String?.self, forKey: .name)
    }
    if container.contains(.properties) {
        properties = try container.decode(ProductPropertiesType?.self, forKey: .properties)
    }
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    if self.id != nil {try container.encode(id, forKey: .id)}
    if self.type != nil {try container.encode(type, forKey: .type)}
    if self.tags != nil {try container.encode(tags, forKey: .tags)}
    if self.location != nil {try container.encode(location, forKey: .location)}
    if self.name != nil {try container.encode(name, forKey: .name)}
    if self.properties != nil {try container.encode(properties as! ProductPropertiesType?, forKey: .properties)}
  }
}


// ProvisioningStateValues enumerates the values for provisioning state values.

public enum ProvisioningStateValues: String, Codable
{
// Accepted specifies the accepted state for provisioning state values.
    case Accepted = "Accepted"
// Canceled specifies the canceled state for provisioning state values.
    case Canceled = "canceled"
// Created specifies the created state for provisioning state values.
    case Created = "Created"
// Creating specifies the creating state for provisioning state values.
    case Creating = "Creating"
// Deleted specifies the deleted state for provisioning state values.
    case Deleted = "Deleted"
// Deleting specifies the deleting state for provisioning state values.
    case Deleting = "Deleting"
// Failed specifies the failed state for provisioning state values.
    case Failed = "Failed"
// OK specifies the ok state for provisioning state values.
    case OK = "OK"
// Succeeded specifies the succeeded state for provisioning state values.
    case Succeeded = "Succeeded"
// Updated specifies the updated state for provisioning state values.
    case Updated = "Updated"
// Updating specifies the updating state for provisioning state values.
    case Updating = "Updating"
}


// ProvisioningStateValues1 enumerates the values for provisioning state values 1.

public enum ProvisioningStateValues1: String, Codable
{
// ProvisioningStateValues1Accepted specifies the provisioning state values 1 accepted state for provisioning state
// values 1.
    case ProvisioningStateValues1Accepted = "Accepted"
// ProvisioningStateValues1Canceled specifies the provisioning state values 1 canceled state for provisioning state
// values 1.
    case ProvisioningStateValues1Canceled = "canceled"
// ProvisioningStateValues1Created specifies the provisioning state values 1 created state for provisioning state
// values 1.
    case ProvisioningStateValues1Created = "Created"
// ProvisioningStateValues1Creating specifies the provisioning state values 1 creating state for provisioning state
// values 1.
    case ProvisioningStateValues1Creating = "Creating"
// ProvisioningStateValues1Deleted specifies the provisioning state values 1 deleted state for provisioning state
// values 1.
    case ProvisioningStateValues1Deleted = "Deleted"
// ProvisioningStateValues1Deleting specifies the provisioning state values 1 deleting state for provisioning state
// values 1.
    case ProvisioningStateValues1Deleting = "Deleting"
// ProvisioningStateValues1Failed specifies the provisioning state values 1 failed state for provisioning state values
// 1.
    case ProvisioningStateValues1Failed = "Failed"
// ProvisioningStateValues1OK specifies the provisioning state values 1ok state for provisioning state values 1.
    case ProvisioningStateValues1OK = "OK"
// ProvisioningStateValues1Succeeded specifies the provisioning state values 1 succeeded state for provisioning state
// values 1.
    case ProvisioningStateValues1Succeeded = "Succeeded"
// ProvisioningStateValues1Updated specifies the provisioning state values 1 updated state for provisioning state
// values 1.
    case ProvisioningStateValues1Updated = "Updated"
// ProvisioningStateValues1Updating specifies the provisioning state values 1 updating state for provisioning state
// values 1.
    case ProvisioningStateValues1Updating = "Updating"
}


import Foundation
public struct ResourceType : ResourceTypeProtocol {
    public var id: String?
    public var type: String?
    public var tags: [String:String?]?
    public var location: String?
    public var name: String?

    enum CodingKeys: String, CodingKey {
        case id = "id"
        case type = "type"
        case tags = "tags"
        case location = "location"
        case name = "name"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.id) {
        id = try container.decode(String?.self, forKey: .id)
    }
    if container.contains(.type) {
        type = try container.decode(String?.self, forKey: .type)
    }
    if container.contains(.tags) {
        tags = try container.decode([String:String?]?.self, forKey: .tags)
    }
    if container.contains(.location) {
        location = try container.decode(String?.self, forKey: .location)
    }
    if container.contains(.name) {
        name = try container.decode(String?.self, forKey: .name)
    }
  }

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


import Foundation
public struct SkuType : SkuTypeProtocol {
    public var name: String?
    public var id: String?

    enum CodingKeys: String, CodingKey {
        case name = "name"
        case id = "id"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.name) {
        name = try container.decode(String?.self, forKey: .name)
    }
    if container.contains(.id) {
        id = try container.decode(String?.self, forKey: .id)
    }
  }

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


import Foundation
public struct SubProductPropertiesType : SubProductPropertiesTypeProtocol {
    public var provisioningState: String?
    public var provisioningStateValues: ProvisioningStateValues?

    enum CodingKeys: String, CodingKey {
        case provisioningState = "provisioningState"
        case provisioningStateValues = "provisioningStateValues"
    }

  public init() {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if container.contains(.provisioningState) {
        provisioningState = try container.decode(String?.self, forKey: .provisioningState)
    }
    if container.contains(.provisioningStateValues) {
        provisioningStateValues = try container.decode(ProvisioningStateValues?.self, forKey: .provisioningStateValues)
    }
  }

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