import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateDiagnosticLogsConfigSlot  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var slot : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var siteLogsConfig :  SiteLogsConfigProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (SiteLogsConfigProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateDiagnosticLogsConfigSlot updates the logging configuration of an app.
    internal class UpdateDiagnosticLogsConfigSlotCommand : BaseCommand, WebAppsUpdateDiagnosticLogsConfigSlot {
        public var resourceGroupName : String
        public var name : String
        public var slot : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var siteLogsConfig :  SiteLogsConfigProtocol?

        public init(resourceGroupName: String, name: String, slot: String, subscriptionId: String, siteLogsConfig: SiteLogsConfigProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.slot = slot
            self.subscriptionId = subscriptionId
            self.siteLogsConfig = siteLogsConfig
            super.init()
            self.method = "Put"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/logs"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{slot}"] = String(describing: self.slot)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = siteLogsConfig

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(siteLogsConfig as? SiteLogsConfigData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(SiteLogsConfigData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (SiteLogsConfigProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: SiteLogsConfigData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateDomainOwnershipIdentifier  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var domainOwnershipIdentifierName : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var domainOwnershipIdentifier :  IdentifierProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (IdentifierProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateDomainOwnershipIdentifier creates a domain ownership identifier for web app, or updates an existing ownership
// identifier.
    internal class UpdateDomainOwnershipIdentifierCommand : BaseCommand, WebAppsUpdateDomainOwnershipIdentifier {
        public var resourceGroupName : String
        public var name : String
        public var domainOwnershipIdentifierName : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var domainOwnershipIdentifier :  IdentifierProtocol?

        public init(resourceGroupName: String, name: String, domainOwnershipIdentifierName: String, subscriptionId: String, domainOwnershipIdentifier: IdentifierProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.domainOwnershipIdentifierName = domainOwnershipIdentifierName
            self.subscriptionId = subscriptionId
            self.domainOwnershipIdentifier = domainOwnershipIdentifier
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/domainOwnershipIdentifiers/{domainOwnershipIdentifierName}"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{domainOwnershipIdentifierName}"] = String(describing: self.domainOwnershipIdentifierName)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = domainOwnershipIdentifier

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(domainOwnershipIdentifier as? IdentifierData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(IdentifierData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (IdentifierProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: IdentifierData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateDomainOwnershipIdentifierSlot  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var domainOwnershipIdentifierName : String { get set }
    var slot : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var domainOwnershipIdentifier :  IdentifierProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (IdentifierProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateDomainOwnershipIdentifierSlot creates a domain ownership identifier for web app, or updates an existing
// ownership identifier.
    internal class UpdateDomainOwnershipIdentifierSlotCommand : BaseCommand, WebAppsUpdateDomainOwnershipIdentifierSlot {
        public var resourceGroupName : String
        public var name : String
        public var domainOwnershipIdentifierName : String
        public var slot : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var domainOwnershipIdentifier :  IdentifierProtocol?

        public init(resourceGroupName: String, name: String, domainOwnershipIdentifierName: String, slot: String, subscriptionId: String, domainOwnershipIdentifier: IdentifierProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.domainOwnershipIdentifierName = domainOwnershipIdentifierName
            self.slot = slot
            self.subscriptionId = subscriptionId
            self.domainOwnershipIdentifier = domainOwnershipIdentifier
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/domainOwnershipIdentifiers/{domainOwnershipIdentifierName}"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{domainOwnershipIdentifierName}"] = String(describing: self.domainOwnershipIdentifierName)
            self.pathParameters["{slot}"] = String(describing: self.slot)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = domainOwnershipIdentifier

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(domainOwnershipIdentifier as? IdentifierData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(IdentifierData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (IdentifierProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: IdentifierData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateHybridConnection  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var namespaceName : String { get set }
    var relayName : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var connectionEnvelope :  HybridConnectionProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (HybridConnectionProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateHybridConnection creates a new Hybrid Connection using a Service Bus relay.
    internal class UpdateHybridConnectionCommand : BaseCommand, WebAppsUpdateHybridConnection {
        public var resourceGroupName : String
        public var name : String
        public var namespaceName : String
        public var relayName : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var connectionEnvelope :  HybridConnectionProtocol?

        public init(resourceGroupName: String, name: String, namespaceName: String, relayName: String, subscriptionId: String, connectionEnvelope: HybridConnectionProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.namespaceName = namespaceName
            self.relayName = relayName
            self.subscriptionId = subscriptionId
            self.connectionEnvelope = connectionEnvelope
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{namespaceName}"] = String(describing: self.namespaceName)
            self.pathParameters["{relayName}"] = String(describing: self.relayName)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = connectionEnvelope

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(connectionEnvelope as? HybridConnectionData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(HybridConnectionData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (HybridConnectionProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: HybridConnectionData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateHybridConnectionSlot  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var namespaceName : String { get set }
    var relayName : String { get set }
    var slot : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var connectionEnvelope :  HybridConnectionProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (HybridConnectionProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateHybridConnectionSlot creates a new Hybrid Connection using a Service Bus relay.
    internal class UpdateHybridConnectionSlotCommand : BaseCommand, WebAppsUpdateHybridConnectionSlot {
        public var resourceGroupName : String
        public var name : String
        public var namespaceName : String
        public var relayName : String
        public var slot : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var connectionEnvelope :  HybridConnectionProtocol?

        public init(resourceGroupName: String, name: String, namespaceName: String, relayName: String, slot: String, subscriptionId: String, connectionEnvelope: HybridConnectionProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.namespaceName = namespaceName
            self.relayName = relayName
            self.slot = slot
            self.subscriptionId = subscriptionId
            self.connectionEnvelope = connectionEnvelope
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{namespaceName}"] = String(describing: self.namespaceName)
            self.pathParameters["{relayName}"] = String(describing: self.relayName)
            self.pathParameters["{slot}"] = String(describing: self.slot)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = connectionEnvelope

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(connectionEnvelope as? HybridConnectionData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(HybridConnectionData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (HybridConnectionProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: HybridConnectionData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateMetadata  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var metadata :  StringDictionaryProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (StringDictionaryProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateMetadata replaces the metadata of an app.
    internal class UpdateMetadataCommand : BaseCommand, WebAppsUpdateMetadata {
        public var resourceGroupName : String
        public var name : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var metadata :  StringDictionaryProtocol?

        public init(resourceGroupName: String, name: String, subscriptionId: String, metadata: StringDictionaryProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.subscriptionId = subscriptionId
            self.metadata = metadata
            super.init()
            self.method = "Put"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/metadata"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = metadata

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(metadata as? StringDictionaryData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(StringDictionaryData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (StringDictionaryProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: StringDictionaryData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateMetadataSlot  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var slot : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var metadata :  StringDictionaryProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (StringDictionaryProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateMetadataSlot replaces the metadata of an app.
    internal class UpdateMetadataSlotCommand : BaseCommand, WebAppsUpdateMetadataSlot {
        public var resourceGroupName : String
        public var name : String
        public var slot : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var metadata :  StringDictionaryProtocol?

        public init(resourceGroupName: String, name: String, slot: String, subscriptionId: String, metadata: StringDictionaryProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.slot = slot
            self.subscriptionId = subscriptionId
            self.metadata = metadata
            super.init()
            self.method = "Put"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/metadata"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{slot}"] = String(describing: self.slot)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = metadata

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(metadata as? StringDictionaryData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(StringDictionaryData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (StringDictionaryProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: StringDictionaryData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateRelayServiceConnection  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var entityName : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var connectionEnvelope :  RelayServiceConnectionEntityProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (RelayServiceConnectionEntityProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateRelayServiceConnection creates a new hybrid connection configuration (PUT), or updates an existing one
// (PATCH).
    internal class UpdateRelayServiceConnectionCommand : BaseCommand, WebAppsUpdateRelayServiceConnection {
        public var resourceGroupName : String
        public var name : String
        public var entityName : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var connectionEnvelope :  RelayServiceConnectionEntityProtocol?

        public init(resourceGroupName: String, name: String, entityName: String, subscriptionId: String, connectionEnvelope: RelayServiceConnectionEntityProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.entityName = entityName
            self.subscriptionId = subscriptionId
            self.connectionEnvelope = connectionEnvelope
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridconnection/{entityName}"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{entityName}"] = String(describing: self.entityName)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = connectionEnvelope

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(connectionEnvelope as? RelayServiceConnectionEntityData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(RelayServiceConnectionEntityData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (RelayServiceConnectionEntityProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: RelayServiceConnectionEntityData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateRelayServiceConnectionSlot  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var entityName : String { get set }
    var slot : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var connectionEnvelope :  RelayServiceConnectionEntityProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (RelayServiceConnectionEntityProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateRelayServiceConnectionSlot creates a new hybrid connection configuration (PUT), or updates an existing one
// (PATCH).
    internal class UpdateRelayServiceConnectionSlotCommand : BaseCommand, WebAppsUpdateRelayServiceConnectionSlot {
        public var resourceGroupName : String
        public var name : String
        public var entityName : String
        public var slot : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var connectionEnvelope :  RelayServiceConnectionEntityProtocol?

        public init(resourceGroupName: String, name: String, entityName: String, slot: String, subscriptionId: String, connectionEnvelope: RelayServiceConnectionEntityProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.entityName = entityName
            self.slot = slot
            self.subscriptionId = subscriptionId
            self.connectionEnvelope = connectionEnvelope
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridconnection/{entityName}"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{entityName}"] = String(describing: self.entityName)
            self.pathParameters["{slot}"] = String(describing: self.slot)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = connectionEnvelope

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(connectionEnvelope as? RelayServiceConnectionEntityData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(RelayServiceConnectionEntityData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (RelayServiceConnectionEntityProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: RelayServiceConnectionEntityData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateSitePushSettings  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var pushSettings :  PushSettingsProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (PushSettingsProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateSitePushSettings updates the Push settings associated with web app.
    internal class UpdateSitePushSettingsCommand : BaseCommand, WebAppsUpdateSitePushSettings {
        public var resourceGroupName : String
        public var name : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var pushSettings :  PushSettingsProtocol?

        public init(resourceGroupName: String, name: String, subscriptionId: String, pushSettings: PushSettingsProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.subscriptionId = subscriptionId
            self.pushSettings = pushSettings
            super.init()
            self.method = "Put"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/pushsettings"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = pushSettings

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(pushSettings as? PushSettingsData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(PushSettingsData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (PushSettingsProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: PushSettingsData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateSitePushSettingsSlot  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var slot : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var pushSettings :  PushSettingsProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (PushSettingsProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateSitePushSettingsSlot updates the Push settings associated with web app.
    internal class UpdateSitePushSettingsSlotCommand : BaseCommand, WebAppsUpdateSitePushSettingsSlot {
        public var resourceGroupName : String
        public var name : String
        public var slot : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var pushSettings :  PushSettingsProtocol?

        public init(resourceGroupName: String, name: String, slot: String, subscriptionId: String, pushSettings: PushSettingsProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.slot = slot
            self.subscriptionId = subscriptionId
            self.pushSettings = pushSettings
            super.init()
            self.method = "Put"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/pushsettings"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{slot}"] = String(describing: self.slot)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = pushSettings

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(pushSettings as? PushSettingsData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(PushSettingsData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (PushSettingsProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: PushSettingsData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateSlot  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var slot : String { get set }
    var subscriptionId : String { get set }
    var skipDnsRegistration : Bool? { get set }
    var skipCustomDomainVerification : Bool? { get set }
    var forceDnsRegistration : Bool? { get set }
    var ttlInSeconds : String? { get set }
    var apiVersion : String { get set }
    var siteEnvelope :  SitePatchResourceProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (SiteProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateSlot creates a new web, mobile, or API app in an existing resource group, or updates an existing app.
    internal class UpdateSlotCommand : BaseCommand, WebAppsUpdateSlot {
        public var resourceGroupName : String
        public var name : String
        public var slot : String
        public var subscriptionId : String
        public var skipDnsRegistration : Bool?
        public var skipCustomDomainVerification : Bool?
        public var forceDnsRegistration : Bool?
        public var ttlInSeconds : String?
        public var apiVersion = "2016-08-01"
    public var siteEnvelope :  SitePatchResourceProtocol?

        public init(resourceGroupName: String, name: String, slot: String, subscriptionId: String, siteEnvelope: SitePatchResourceProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.slot = slot
            self.subscriptionId = subscriptionId
            self.siteEnvelope = siteEnvelope
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{slot}"] = String(describing: self.slot)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            if self.skipDnsRegistration != nil { queryParameters["skipDnsRegistration"] = String(describing: self.skipDnsRegistration!) }
            if self.skipCustomDomainVerification != nil { queryParameters["skipCustomDomainVerification"] = String(describing: self.skipCustomDomainVerification!) }
            if self.forceDnsRegistration != nil { queryParameters["forceDnsRegistration"] = String(describing: self.forceDnsRegistration!) }
            if self.ttlInSeconds != nil { queryParameters["ttlInSeconds"] = String(describing: self.ttlInSeconds!) }
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = siteEnvelope

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(siteEnvelope as? SitePatchResourceData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(SiteData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (SiteProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: SiteData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateSlotConfigurationNames  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var slotConfigNames :  SlotConfigNamesResourceProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (SlotConfigNamesResourceProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateSlotConfigurationNames updates the names of application settings and connection string that remain with the
// slot during swap operation.
    internal class UpdateSlotConfigurationNamesCommand : BaseCommand, WebAppsUpdateSlotConfigurationNames {
        public var resourceGroupName : String
        public var name : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var slotConfigNames :  SlotConfigNamesResourceProtocol?

        public init(resourceGroupName: String, name: String, subscriptionId: String, slotConfigNames: SlotConfigNamesResourceProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.subscriptionId = subscriptionId
            self.slotConfigNames = slotConfigNames
            super.init()
            self.method = "Put"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/slotConfigNames"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = slotConfigNames

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(slotConfigNames as? SlotConfigNamesResourceData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(SlotConfigNamesResourceData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (SlotConfigNamesResourceProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: SlotConfigNamesResourceData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateSourceControl  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var siteSourceControl :  SiteSourceControlProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (SiteSourceControlProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateSourceControl updates the source control configuration of an app.
    internal class UpdateSourceControlCommand : BaseCommand, WebAppsUpdateSourceControl {
        public var resourceGroupName : String
        public var name : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var siteSourceControl :  SiteSourceControlProtocol?

        public init(resourceGroupName: String, name: String, subscriptionId: String, siteSourceControl: SiteSourceControlProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.subscriptionId = subscriptionId
            self.siteSourceControl = siteSourceControl
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/sourcecontrols/web"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = siteSourceControl

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(siteSourceControl as? SiteSourceControlData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(SiteSourceControlData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (SiteSourceControlProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: SiteSourceControlData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateSourceControlSlot  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var slot : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var siteSourceControl :  SiteSourceControlProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (SiteSourceControlProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateSourceControlSlot updates the source control configuration of an app.
    internal class UpdateSourceControlSlotCommand : BaseCommand, WebAppsUpdateSourceControlSlot {
        public var resourceGroupName : String
        public var name : String
        public var slot : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var siteSourceControl :  SiteSourceControlProtocol?

        public init(resourceGroupName: String, name: String, slot: String, subscriptionId: String, siteSourceControl: SiteSourceControlProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.slot = slot
            self.subscriptionId = subscriptionId
            self.siteSourceControl = siteSourceControl
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/sourcecontrols/web"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{slot}"] = String(describing: self.slot)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = siteSourceControl

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(siteSourceControl as? SiteSourceControlData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(SiteSourceControlData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (SiteSourceControlProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: SiteSourceControlData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateVnetConnection  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var vnetName : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var connectionEnvelope :  VnetInfoProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (VnetInfoProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateVnetConnection adds a Virtual Network connection to an app or slot (PUT) or updates the connection properties
// (PATCH).
    internal class UpdateVnetConnectionCommand : BaseCommand, WebAppsUpdateVnetConnection {
        public var resourceGroupName : String
        public var name : String
        public var vnetName : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var connectionEnvelope :  VnetInfoProtocol?

        public init(resourceGroupName: String, name: String, vnetName: String, subscriptionId: String, connectionEnvelope: VnetInfoProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.vnetName = vnetName
            self.subscriptionId = subscriptionId
            self.connectionEnvelope = connectionEnvelope
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/virtualNetworkConnections/{vnetName}"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{vnetName}"] = String(describing: self.vnetName)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = connectionEnvelope

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(connectionEnvelope as? VnetInfoData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(VnetInfoData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (VnetInfoProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: VnetInfoData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateVnetConnectionGateway  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var vnetName : String { get set }
    var gatewayName : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var connectionEnvelope :  VnetGatewayProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (VnetGatewayProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateVnetConnectionGateway adds a gateway to a connected Virtual Network (PUT) or updates it (PATCH).
    internal class UpdateVnetConnectionGatewayCommand : BaseCommand, WebAppsUpdateVnetConnectionGateway {
        public var resourceGroupName : String
        public var name : String
        public var vnetName : String
        public var gatewayName : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var connectionEnvelope :  VnetGatewayProtocol?

        public init(resourceGroupName: String, name: String, vnetName: String, gatewayName: String, subscriptionId: String, connectionEnvelope: VnetGatewayProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.vnetName = vnetName
            self.gatewayName = gatewayName
            self.subscriptionId = subscriptionId
            self.connectionEnvelope = connectionEnvelope
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/virtualNetworkConnections/{vnetName}/gateways/{gatewayName}"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{vnetName}"] = String(describing: self.vnetName)
            self.pathParameters["{gatewayName}"] = String(describing: self.gatewayName)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = connectionEnvelope

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(connectionEnvelope as? VnetGatewayData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(VnetGatewayData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (VnetGatewayProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: VnetGatewayData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateVnetConnectionGatewaySlot  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var vnetName : String { get set }
    var gatewayName : String { get set }
    var slot : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var connectionEnvelope :  VnetGatewayProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (VnetGatewayProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateVnetConnectionGatewaySlot adds a gateway to a connected Virtual Network (PUT) or updates it (PATCH).
    internal class UpdateVnetConnectionGatewaySlotCommand : BaseCommand, WebAppsUpdateVnetConnectionGatewaySlot {
        public var resourceGroupName : String
        public var name : String
        public var vnetName : String
        public var gatewayName : String
        public var slot : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var connectionEnvelope :  VnetGatewayProtocol?

        public init(resourceGroupName: String, name: String, vnetName: String, gatewayName: String, slot: String, subscriptionId: String, connectionEnvelope: VnetGatewayProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.vnetName = vnetName
            self.gatewayName = gatewayName
            self.slot = slot
            self.subscriptionId = subscriptionId
            self.connectionEnvelope = connectionEnvelope
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/virtualNetworkConnections/{vnetName}/gateways/{gatewayName}"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{vnetName}"] = String(describing: self.vnetName)
            self.pathParameters["{gatewayName}"] = String(describing: self.gatewayName)
            self.pathParameters["{slot}"] = String(describing: self.slot)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = connectionEnvelope

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(connectionEnvelope as? VnetGatewayData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(VnetGatewayData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (VnetGatewayProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: VnetGatewayData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


import Foundation
import azureSwiftRuntime
public protocol WebAppsUpdateVnetConnectionSlot  {
    var headerParameters: [String: String] { get set }
    var resourceGroupName : String { get set }
    var name : String { get set }
    var vnetName : String { get set }
    var slot : String { get set }
    var subscriptionId : String { get set }
    var apiVersion : String { get set }
    var connectionEnvelope :  VnetInfoProtocol?  { get set }
    func execute(client: RuntimeClient,
    completionHandler: @escaping (VnetInfoProtocol?, Error?) -> Void) -> Void ;
}

extension Commands.WebApps {
// UpdateVnetConnectionSlot adds a Virtual Network connection to an app or slot (PUT) or updates the connection
// properties (PATCH).
    internal class UpdateVnetConnectionSlotCommand : BaseCommand, WebAppsUpdateVnetConnectionSlot {
        public var resourceGroupName : String
        public var name : String
        public var vnetName : String
        public var slot : String
        public var subscriptionId : String
        public var apiVersion = "2016-08-01"
    public var connectionEnvelope :  VnetInfoProtocol?

        public init(resourceGroupName: String, name: String, vnetName: String, slot: String, subscriptionId: String, connectionEnvelope: VnetInfoProtocol) {
            self.resourceGroupName = resourceGroupName
            self.name = name
            self.vnetName = vnetName
            self.slot = slot
            self.subscriptionId = subscriptionId
            self.connectionEnvelope = connectionEnvelope
            super.init()
            self.method = "Patch"
            self.isLongRunningOperation = false
            self.path = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/virtualNetworkConnections/{vnetName}"
            self.headerParameters = ["Content-Type":"application/json; charset=utf-8"]
        }

        public override func preCall()  {
            self.pathParameters["{resourceGroupName}"] = String(describing: self.resourceGroupName)
            self.pathParameters["{name}"] = String(describing: self.name)
            self.pathParameters["{vnetName}"] = String(describing: self.vnetName)
            self.pathParameters["{slot}"] = String(describing: self.slot)
            self.pathParameters["{subscriptionId}"] = String(describing: self.subscriptionId)
            self.queryParameters["api-version"] = String(describing: self.apiVersion)
            self.body = connectionEnvelope

        }
        public override func encodeBody() throws -> Data? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let encoder = try CoderFactory.encoder(for: mimeType)
                let encodedValue = try encoder.encode(connectionEnvelope as? VnetInfoData)
                return encodedValue
            }
            throw DecodeError.unknownMimeType
        }

        public override func returnFunc(data: Data) throws -> Decodable? {
            let contentType = "application/json"
            if let mimeType = MimeType.getType(forStr: contentType) {
                let decoder = try CoderFactory.decoder(for: mimeType)
                let result = try decoder.decode(VnetInfoData?.self, from: data)
                return result;
            }
            throw DecodeError.unknownMimeType
        }
        public func execute(client: RuntimeClient,
            completionHandler: @escaping (VnetInfoProtocol?, Error?) -> Void) -> Void {
            client.executeAsync(command: self) {
                (result: VnetInfoData?, error: Error?) in
                completionHandler(result, error)
            }
        }
    }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct AbnormalTimePeriodData : AbnormalTimePeriodProtocol {
    public var startTime: Date?
    public var endTime: Date?
    public var events: [DetectorAbnormalTimePeriodProtocol?]?
    public var solutions: [SolutionProtocol?]?

        enum CodingKeys: String, CodingKey {case startTime = "startTime"
        case endTime = "endTime"
        case events = "events"
        case solutions = "solutions"
        }

  public init()  {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      if container.contains(.startTime) {
        self.startTime = DateConverter.fromString(dateStr: (try container.decode(String?.self, forKey: .startTime)), format: .dateTime)
    }
    if container.contains(.endTime) {
        self.endTime = DateConverter.fromString(dateStr: (try container.decode(String?.self, forKey: .endTime)), format: .dateTime)
    }
    if container.contains(.events) {
        self.events = try container.decode([DetectorAbnormalTimePeriodData?]?.self, forKey: .events)
    }
    if container.contains(.solutions) {
        self.solutions = try container.decode([SolutionData?]?.self, forKey: .solutions)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    if self.startTime != nil {
        try container.encode(DateConverter.toString(date: self.startTime!, format: .dateTime), forKey: .startTime)
    }
    if self.endTime != nil {
        try container.encode(DateConverter.toString(date: self.endTime!, format: .dateTime), forKey: .endTime)
    }
    if self.events != nil {try container.encode(self.events as! [DetectorAbnormalTimePeriodData?]?, forKey: .events)}
    if self.solutions != nil {try container.encode(self.solutions as! [SolutionData?]?, forKey: .solutions)}
  }
}

extension DataFactory {
  public static func createAbnormalTimePeriodProtocol() -> AbnormalTimePeriodProtocol {
    return AbnormalTimePeriodData()
  }
}


// AccessControlEntryAction enumerates the values for access control entry action.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
public enum AccessControlEntryActionEnum: String, Codable
{
// Deny specifies the deny state for access control entry action.
    case Deny = "Deny"
// Permit specifies the permit state for access control entry action.
    case Permit = "Permit"
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct AddressData : AddressProtocol {
    public var address1: String
    public var address2: String?
    public var city: String
    public var country: String
    public var postalCode: String
    public var state: String

        enum CodingKeys: String, CodingKey {case address1 = "address1"
        case address2 = "address2"
        case city = "city"
        case country = "country"
        case postalCode = "postalCode"
        case state = "state"
        }

  public init(address1: String, city: String, country: String, postalCode: String, state: String)  {
    self.address1 = address1
    self.city = city
    self.country = country
    self.postalCode = postalCode
    self.state = state
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      self.address1 = try container.decode(String.self, forKey: .address1)
    if container.contains(.address2) {
        self.address2 = try container.decode(String?.self, forKey: .address2)
    }
    self.city = try container.decode(String.self, forKey: .city)
    self.country = try container.decode(String.self, forKey: .country)
    self.postalCode = try container.decode(String.self, forKey: .postalCode)
    self.state = try container.decode(String.self, forKey: .state)
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encode(self.address1, forKey: .address1)
    if self.address2 != nil {try container.encode(self.address2, forKey: .address2)}
    try container.encode(self.city, forKey: .city)
    try container.encode(self.country, forKey: .country)
    try container.encode(self.postalCode, forKey: .postalCode)
    try container.encode(self.state, forKey: .state)
  }
}

extension DataFactory {
  public static func createAddressProtocol(address1: String, city: String, country: String, postalCode: String, state: String) -> AddressProtocol {
    return AddressData(address1: address1, city: city, country: country, postalCode: postalCode, state: state)
  }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct AddressResponseData : AddressResponseProtocol {
    public var serviceIpAddress: String?
    public var internalIpAddress: String?
    public var outboundIpAddresses: [String]?
    public var vipMappings: [VirtualIPMappingProtocol?]?

        enum CodingKeys: String, CodingKey {case serviceIpAddress = "serviceIpAddress"
        case internalIpAddress = "internalIpAddress"
        case outboundIpAddresses = "outboundIpAddresses"
        case vipMappings = "vipMappings"
        }

  public init()  {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      if container.contains(.serviceIpAddress) {
        self.serviceIpAddress = try container.decode(String?.self, forKey: .serviceIpAddress)
    }
    if container.contains(.internalIpAddress) {
        self.internalIpAddress = try container.decode(String?.self, forKey: .internalIpAddress)
    }
    if container.contains(.outboundIpAddresses) {
        self.outboundIpAddresses = try container.decode([String]?.self, forKey: .outboundIpAddresses)
    }
    if container.contains(.vipMappings) {
        self.vipMappings = try container.decode([VirtualIPMappingData?]?.self, forKey: .vipMappings)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    if self.serviceIpAddress != nil {try container.encode(self.serviceIpAddress, forKey: .serviceIpAddress)}
    if self.internalIpAddress != nil {try container.encode(self.internalIpAddress, forKey: .internalIpAddress)}
    if self.outboundIpAddresses != nil {try container.encode(self.outboundIpAddresses as! [String]?, forKey: .outboundIpAddresses)}
    if self.vipMappings != nil {try container.encode(self.vipMappings as! [VirtualIPMappingData?]?, forKey: .vipMappings)}
  }
}

extension DataFactory {
  public static func createAddressResponseProtocol() -> AddressResponseProtocol {
    return AddressResponseData()
  }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct AnalysisDataData : AnalysisDataProtocol {
    public var source: String?
    public var detectorDefinition: DetectorDefinitionProtocol?
    public var metrics: [DiagnosticMetricSetProtocol?]?
    public var data: [[NameValuePairProtocol?]?]?
    public var detectorMetaData: ResponseMetaDataProtocol?

        enum CodingKeys: String, CodingKey {case source = "source"
        case detectorDefinition = "detectorDefinition"
        case metrics = "metrics"
        case data = "data"
        case detectorMetaData = "detectorMetaData"
        }

  public init()  {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      if container.contains(.source) {
        self.source = try container.decode(String?.self, forKey: .source)
    }
    if container.contains(.detectorDefinition) {
        self.detectorDefinition = try container.decode(DetectorDefinitionData?.self, forKey: .detectorDefinition)
    }
    if container.contains(.metrics) {
        self.metrics = try container.decode([DiagnosticMetricSetData?]?.self, forKey: .metrics)
    }
    if container.contains(.data) {
        self.data = try container.decode([[NameValuePairData?]?]?.self, forKey: .data)
    }
    if container.contains(.detectorMetaData) {
        self.detectorMetaData = try container.decode(ResponseMetaDataData?.self, forKey: .detectorMetaData)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    if self.source != nil {try container.encode(self.source, forKey: .source)}
    if self.detectorDefinition != nil {try container.encode(self.detectorDefinition as! DetectorDefinitionData?, forKey: .detectorDefinition)}
    if self.metrics != nil {try container.encode(self.metrics as! [DiagnosticMetricSetData?]?, forKey: .metrics)}
    if self.data != nil {try container.encode(self.data as! [[NameValuePairData?]?]?, forKey: .data)}
    if self.detectorMetaData != nil {try container.encode(self.detectorMetaData as! ResponseMetaDataData?, forKey: .detectorMetaData)}
  }
}

extension DataFactory {
  public static func createAnalysisDataProtocol() -> AnalysisDataProtocol {
    return AnalysisDataData()
  }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct AnalysisDefinitionData : AnalysisDefinitionProtocol, ProxyOnlyResourceProtocol {
    public var id: String?
    public var name: String?
    public var kind: String?
    public var type: String?
    public var properties: AnalysisDefinitionPropertiesProtocol?

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

  public init()  {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      if container.contains(.id) {
        self.id = try container.decode(String?.self, forKey: .id)
    }
    if container.contains(.name) {
        self.name = try container.decode(String?.self, forKey: .name)
    }
    if container.contains(.kind) {
        self.kind = try container.decode(String?.self, forKey: .kind)
    }
    if container.contains(.type) {
        self.type = try container.decode(String?.self, forKey: .type)
    }
    if container.contains(.properties) {
        self.properties = try container.decode(AnalysisDefinitionPropertiesData?.self, forKey: .properties)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

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

extension DataFactory {
  public static func createAnalysisDefinitionProtocol() -> AnalysisDefinitionProtocol {
    return AnalysisDefinitionData()
  }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct AnalysisDefinitionPropertiesData : AnalysisDefinitionPropertiesProtocol {
    public var description: String?

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

  public init()  {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      if container.contains(.description) {
        self.description = try container.decode(String?.self, forKey: .description)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

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

extension DataFactory {
  public static func createAnalysisDefinitionPropertiesProtocol() -> AnalysisDefinitionPropertiesProtocol {
    return AnalysisDefinitionPropertiesData()
  }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct ApiDefinitionInfoData : ApiDefinitionInfoProtocol {
    public var url: String?

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

  public init()  {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      if container.contains(.url) {
        self.url = try container.decode(String?.self, forKey: .url)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

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

extension DataFactory {
  public static func createApiDefinitionInfoProtocol() -> ApiDefinitionInfoProtocol {
    return ApiDefinitionInfoData()
  }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct ApplicationLogsConfigData : ApplicationLogsConfigProtocol {
    public var fileSystem: FileSystemApplicationLogsConfigProtocol?
    public var azureTableStorage: AzureTableStorageApplicationLogsConfigProtocol?
    public var azureBlobStorage: AzureBlobStorageApplicationLogsConfigProtocol?

        enum CodingKeys: String, CodingKey {case fileSystem = "fileSystem"
        case azureTableStorage = "azureTableStorage"
        case azureBlobStorage = "azureBlobStorage"
        }

  public init()  {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      if container.contains(.fileSystem) {
        self.fileSystem = try container.decode(FileSystemApplicationLogsConfigData?.self, forKey: .fileSystem)
    }
    if container.contains(.azureTableStorage) {
        self.azureTableStorage = try container.decode(AzureTableStorageApplicationLogsConfigData?.self, forKey: .azureTableStorage)
    }
    if container.contains(.azureBlobStorage) {
        self.azureBlobStorage = try container.decode(AzureBlobStorageApplicationLogsConfigData?.self, forKey: .azureBlobStorage)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    if self.fileSystem != nil {try container.encode(self.fileSystem as! FileSystemApplicationLogsConfigData?, forKey: .fileSystem)}
    if self.azureTableStorage != nil {try container.encode(self.azureTableStorage as! AzureTableStorageApplicationLogsConfigData?, forKey: .azureTableStorage)}
    if self.azureBlobStorage != nil {try container.encode(self.azureBlobStorage as! AzureBlobStorageApplicationLogsConfigData?, forKey: .azureBlobStorage)}
  }
}

extension DataFactory {
  public static func createApplicationLogsConfigProtocol() -> ApplicationLogsConfigProtocol {
    return ApplicationLogsConfigData()
  }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct ApplicationStackCollectionData : ApplicationStackCollectionProtocol {
    public var value: [ApplicationStackProtocol]
    public var _nextLink: String?

        enum CodingKeys: String, CodingKey {case value = "value"
        case _nextLink = "nextLink"
        }

  public init(value: [ApplicationStackProtocol])  {
    self.value = value
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      self.value = try container.decode([ApplicationStackData].self, forKey: .value)
    if container.contains(._nextLink) {
        self._nextLink = try container.decode(String?.self, forKey: ._nextLink)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encode(self.value as! [ApplicationStackData], forKey: .value)
    if self._nextLink != nil {try container.encode(self._nextLink, forKey: ._nextLink)}
  }
}

extension DataFactory {
  public static func createApplicationStackCollectionProtocol(value: [ApplicationStackProtocol]) -> ApplicationStackCollectionProtocol {
    return ApplicationStackCollectionData(value: value)
  }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct ApplicationStackData : ApplicationStackProtocol {
    public var name: String?
    public var display: String?
    public var dependency: String?
    public var majorVersions: [StackMajorVersionProtocol?]?
    public var frameworks: [ApplicationStackProtocol?]?

        enum CodingKeys: String, CodingKey {case name = "name"
        case display = "display"
        case dependency = "dependency"
        case majorVersions = "majorVersions"
        case frameworks = "frameworks"
        }

  public init()  {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      if container.contains(.name) {
        self.name = try container.decode(String?.self, forKey: .name)
    }
    if container.contains(.display) {
        self.display = try container.decode(String?.self, forKey: .display)
    }
    if container.contains(.dependency) {
        self.dependency = try container.decode(String?.self, forKey: .dependency)
    }
    if container.contains(.majorVersions) {
        self.majorVersions = try container.decode([StackMajorVersionData?]?.self, forKey: .majorVersions)
    }
    if container.contains(.frameworks) {
        self.frameworks = try container.decode([ApplicationStackData?]?.self, forKey: .frameworks)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    if self.name != nil {try container.encode(self.name, forKey: .name)}
    if self.display != nil {try container.encode(self.display, forKey: .display)}
    if self.dependency != nil {try container.encode(self.dependency, forKey: .dependency)}
    if self.majorVersions != nil {try container.encode(self.majorVersions as! [StackMajorVersionData?]?, forKey: .majorVersions)}
    if self.frameworks != nil {try container.encode(self.frameworks as! [ApplicationStackData?]?, forKey: .frameworks)}
  }
}

extension DataFactory {
  public static func createApplicationStackProtocol() -> ApplicationStackProtocol {
    return ApplicationStackData()
  }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct AppServiceCertificateCollectionData : AppServiceCertificateCollectionProtocol {
    public var value: [AppServiceCertificateResourceProtocol]
    public var _nextLink: String?

        enum CodingKeys: String, CodingKey {case value = "value"
        case _nextLink = "nextLink"
        }

  public init(value: [AppServiceCertificateResourceProtocol])  {
    self.value = value
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      self.value = try container.decode([AppServiceCertificateResourceData].self, forKey: .value)
    if container.contains(._nextLink) {
        self._nextLink = try container.decode(String?.self, forKey: ._nextLink)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encode(self.value as! [AppServiceCertificateResourceData], forKey: .value)
    if self._nextLink != nil {try container.encode(self._nextLink, forKey: ._nextLink)}
  }
}

extension DataFactory {
  public static func createAppServiceCertificateCollectionProtocol(value: [AppServiceCertificateResourceProtocol]) -> AppServiceCertificateCollectionProtocol {
    return AppServiceCertificateCollectionData(value: value)
  }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct AppServiceCertificateData : AppServiceCertificateProtocol {
    public var keyVaultId: String?
    public var keyVaultSecretName: String?
    public var provisioningState: KeyVaultSecretStatusEnum?

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

  public init()  {
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      if container.contains(.keyVaultId) {
        self.keyVaultId = try container.decode(String?.self, forKey: .keyVaultId)
    }
    if container.contains(.keyVaultSecretName) {
        self.keyVaultSecretName = try container.decode(String?.self, forKey: .keyVaultSecretName)
    }
    if container.contains(.provisioningState) {
        self.provisioningState = try container.decode(KeyVaultSecretStatusEnum?.self, forKey: .provisioningState)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

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

extension DataFactory {
  public static func createAppServiceCertificateProtocol() -> AppServiceCertificateProtocol {
    return AppServiceCertificateData()
  }
}


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
import azureSwiftRuntime
internal struct AppServiceCertificateOrderCollectionData : AppServiceCertificateOrderCollectionProtocol {
    public var value: [AppServiceCertificateOrderProtocol]
    public var _nextLink: String?

        enum CodingKeys: String, CodingKey {case value = "value"
        case _nextLink = "nextLink"
        }

  public init(value: [AppServiceCertificateOrderProtocol])  {
    self.value = value
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
      self.value = try container.decode([AppServiceCertificateOrderData].self, forKey: .value)
    if container.contains(._nextLink) {
        self._nextLink = try container.decode(String?.self, forKey: ._nextLink)
    }
    if var pageDecoder = decoder as? PageDecoder  {
      if pageDecoder.isPagedData,
        let nextLinkName = pageDecoder.nextLinkName {
          pageDecoder.nextLink = try UnknownCodingKey.decodeStringForKey(decoder: decoder, keyForDecode: nextLinkName)
      }
    }
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encode(self.value as! [AppServiceCertificateOrderData], forKey: .value)
    if self._nextLink != nil {try container.encode(self._nextLink, forKey: ._nextLink)}
  }
}

extension DataFactory {
  public static func createAppServiceCertificateOrderCollectionProtocol(value: [AppServiceCertificateOrderProtocol]) -> AppServiceCertificateOrderCollectionProtocol {
    return AppServiceCertificateOrderCollectionData(value: value)
  }
}