fastlane_pricing_fix 2.212.1

data/fastlane/swift/GymfileProtocol.swift

@@ -0,0 +1,211 @@
+// GymfileProtocol.swift
+// Copyright (c) 2023 FastlaneTools
+
+public protocol GymfileProtocol: AnyObject {
+    /// Path to the workspace file
+    var workspace: String? { get }
+
+    /// Path to the project file
+    var project: String? { get }
+
+    /// The project's scheme. Make sure it's marked as `Shared`
+    var scheme: String? { get }
+
+    /// Should the project be cleaned before building it?
+    var clean: Bool { get }
+
+    /// The directory in which the ipa file should be stored in
+    var outputDirectory: String { get }
+
+    /// The name of the resulting ipa file
+    var outputName: String? { get }
+
+    /// The configuration to use when building the app. Defaults to 'Release'
+    var configuration: String? { get }
+
+    /// Hide all information that's not necessary while building
+    var silent: Bool { get }
+
+    /// The name of the code signing identity to use. It has to match the name exactly. e.g. 'iPhone Distribution: SunApps GmbH'
+    var codesigningIdentity: String? { get }
+
+    /// Should we skip packaging the ipa?
+    var skipPackageIpa: Bool { get }
+
+    /// Should we skip packaging the pkg?
+    var skipPackagePkg: Bool { get }
+
+    /// Should the ipa file include symbols?
+    var includeSymbols: Bool? { get }
+
+    /// Should the ipa file include bitcode?
+    var includeBitcode: Bool? { get }
+
+    /// Method used to export the archive. Valid values are: app-store, validation, ad-hoc, package, enterprise, development, developer-id and mac-application
+    var exportMethod: String? { get }
+
+    /// Path to an export options plist or a hash with export options. Use 'xcodebuild -help' to print the full set of available options
+    var exportOptions: [String: Any]? { get }
+
+    /// Pass additional arguments to xcodebuild for the package phase. Be sure to quote the setting names and values e.g. OTHER_LDFLAGS="-ObjC -lstdc++"
+    var exportXcargs: String? { get }
+
+    /// Export ipa from previously built xcarchive. Uses archive_path as source
+    var skipBuildArchive: Bool? { get }
+
+    /// After building, don't archive, effectively not including -archivePath param
+    var skipArchive: Bool? { get }
+
+    /// Build without codesigning
+    var skipCodesigning: Bool? { get }
+
+    /// Platform to build when using a Catalyst enabled app. Valid values are: ios, macos
+    var catalystPlatform: String? { get }
+
+    /// Full name of 3rd Party Mac Developer Installer or Developer ID Installer certificate. Example: `3rd Party Mac Developer Installer: Your Company (ABC1234XWYZ)`
+    var installerCertName: String? { get }
+
+    /// The directory in which the archive should be stored in
+    var buildPath: String? { get }
+
+    /// The path to the created archive
+    var archivePath: String? { get }
+
+    /// The directory where built products and other derived data will go
+    var derivedDataPath: String? { get }
+
+    /// Should an Xcode result bundle be generated in the output directory
+    var resultBundle: Bool { get }
+
+    /// Path to the result bundle directory to create. Ignored if `result_bundle` if false
+    var resultBundlePath: String? { get }
+
+    /// The directory where to store the build log
+    var buildlogPath: String { get }
+
+    /// The SDK that should be used for building the application
+    var sdk: String? { get }
+
+    /// The toolchain that should be used for building the application (e.g. com.apple.dt.toolchain.Swift_2_3, org.swift.30p620160816a)
+    var toolchain: String? { get }
+
+    /// Use a custom destination for building the app
+    var destination: String? { get }
+
+    /// Optional: Sometimes you need to specify a team id when exporting the ipa file
+    var exportTeamId: String? { get }
+
+    /// Pass additional arguments to xcodebuild for the build phase. Be sure to quote the setting names and values e.g. OTHER_LDFLAGS="-ObjC -lstdc++"
+    var xcargs: String? { get }
+
+    /// Use an extra XCCONFIG file to build your app
+    var xcconfig: String? { get }
+
+    /// Suppress the output of xcodebuild to stdout. Output is still saved in buildlog_path
+    var suppressXcodeOutput: Bool? { get }
+
+    /// xcodebuild formatter to use (ex: 'xcbeautify', 'xcbeautify --quieter', 'xcpretty', 'xcpretty -test'). Use empty string (ex: '') to disable any formatter (More information: https://docs.fastlane.tools/best-practices/xcodebuild-formatters/)
+    var xcodebuildFormatter: String { get }
+
+    /// Create a build timing summary
+    var buildTimingSummary: Bool { get }
+
+    /// **DEPRECATED!** Use `xcodebuild_formatter: ''` instead - Disable xcpretty formatting of build output
+    var disableXcpretty: Bool? { get }
+
+    /// Use the test (RSpec style) format for build output
+    var xcprettyTestFormat: Bool? { get }
+
+    /// A custom xcpretty formatter to use
+    var xcprettyFormatter: String? { get }
+
+    /// Have xcpretty create a JUnit-style XML report at the provided path
+    var xcprettyReportJunit: String? { get }
+
+    /// Have xcpretty create a simple HTML report at the provided path
+    var xcprettyReportHtml: String? { get }
+
+    /// Have xcpretty create a JSON compilation database at the provided path
+    var xcprettyReportJson: String? { get }
+
+    /// Have xcpretty use unicode encoding when reporting builds
+    var xcprettyUtf: Bool? { get }
+
+    /// Analyze the project build time and store the output in 'culprits.txt' file
+    var analyzeBuildTime: Bool? { get }
+
+    /// Do not try to build a profile mapping from the xcodeproj. Match or a manually provided mapping should be used
+    var skipProfileDetection: Bool { get }
+
+    /// Allows for override of the default `xcodebuild` command
+    var xcodebuildCommand: String { get }
+
+    /// Sets a custom path for Swift Package Manager dependencies
+    var clonedSourcePackagesPath: String? { get }
+
+    /// Skips resolution of Swift Package Manager dependencies
+    var skipPackageDependenciesResolution: Bool { get }
+
+    /// Prevents packages from automatically being resolved to versions other than those recorded in the `Package.resolved` file
+    var disablePackageAutomaticUpdates: Bool { get }
+
+    /// Lets xcodebuild use system's scm configuration
+    var useSystemScm: Bool { get }
+}
+
+public extension GymfileProtocol {
+    var workspace: String? { return nil }
+    var project: String? { return nil }
+    var scheme: String? { return nil }
+    var clean: Bool { return false }
+    var outputDirectory: String { return "." }
+    var outputName: String? { return nil }
+    var configuration: String? { return nil }
+    var silent: Bool { return false }
+    var codesigningIdentity: String? { return nil }
+    var skipPackageIpa: Bool { return false }
+    var skipPackagePkg: Bool { return false }
+    var includeSymbols: Bool? { return nil }
+    var includeBitcode: Bool? { return nil }
+    var exportMethod: String? { return nil }
+    var exportOptions: [String: Any]? { return nil }
+    var exportXcargs: String? { return nil }
+    var skipBuildArchive: Bool? { return nil }
+    var skipArchive: Bool? { return nil }
+    var skipCodesigning: Bool? { return nil }
+    var catalystPlatform: String? { return nil }
+    var installerCertName: String? { return nil }
+    var buildPath: String? { return nil }
+    var archivePath: String? { return nil }
+    var derivedDataPath: String? { return nil }
+    var resultBundle: Bool { return false }
+    var resultBundlePath: String? { return nil }
+    var buildlogPath: String { return "~/Library/Logs/gym" }
+    var sdk: String? { return nil }
+    var toolchain: String? { return nil }
+    var destination: String? { return nil }
+    var exportTeamId: String? { return nil }
+    var xcargs: String? { return nil }
+    var xcconfig: String? { return nil }
+    var suppressXcodeOutput: Bool? { return nil }
+    var xcodebuildFormatter: String { return "xcbeautify" }
+    var buildTimingSummary: Bool { return false }
+    var disableXcpretty: Bool? { return nil }
+    var xcprettyTestFormat: Bool? { return nil }
+    var xcprettyFormatter: String? { return nil }
+    var xcprettyReportJunit: String? { return nil }
+    var xcprettyReportHtml: String? { return nil }
+    var xcprettyReportJson: String? { return nil }
+    var xcprettyUtf: Bool? { return nil }
+    var analyzeBuildTime: Bool? { return nil }
+    var skipProfileDetection: Bool { return false }
+    var xcodebuildCommand: String { return "xcodebuild" }
+    var clonedSourcePackagesPath: String? { return nil }
+    var skipPackageDependenciesResolution: Bool { return false }
+    var disablePackageAutomaticUpdates: Bool { return false }
+    var useSystemScm: Bool { return false }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.117]

data/fastlane/swift/LaneFileProtocol.swift

@@ -0,0 +1,155 @@
+// LaneFileProtocol.swift
+// Copyright (c) 2023 FastlaneTools
+
+//
+//  ** NOTE **
+//  This file is provided by fastlane and WILL be overwritten in future updates
+//  If you want to add extra functionality to this project, create a new file in a
+//  new group so that it won't be marked for upgrade
+//
+
+import Foundation
+
+public protocol LaneFileProtocol: AnyObject {
+    var fastlaneVersion: String { get }
+    static func runLane(from fastfile: LaneFile?, named lane: String, with parameters: [String: String]) -> Bool
+
+    func recordLaneDescriptions()
+    func beforeAll(with lane: String)
+    func afterAll(with lane: String)
+    func onError(currentLane: String, errorInfo: String, errorClass: String?, errorMessage: String?)
+}
+
+public extension LaneFileProtocol {
+    var fastlaneVersion: String { return "" } // Defaults to "" because that means any is fine
+    func beforeAll(with _: String) {} // No-op by default
+    func afterAll(with _: String) {} // No-op by default
+    func recordLaneDescriptions() {} // No-op by default
+}
+
+@objcMembers
+open class LaneFile: NSObject, LaneFileProtocol {
+    private(set) static var fastfileInstance: LaneFile?
+    private static var onErrorCalled = Set<String>()
+
+    private static func trimLaneFromName(laneName: String) -> String {
+        return String(laneName.prefix(laneName.count - 4))
+    }
+
+    private static func trimLaneWithOptionsFromName(laneName: String) -> String {
+        return String(laneName.prefix(laneName.count - 12))
+    }
+
+    public func onError(currentLane: String, errorInfo _: String, errorClass _: String?, errorMessage _: String?) {
+        LaneFile.onErrorCalled.insert(currentLane)
+    }
+
+    private static var laneFunctionNames: [String] {
+        var lanes: [String] = []
+        var methodCount: UInt32 = 0
+        #if !SWIFT_PACKAGE
+            let methodList = class_copyMethodList(self, &methodCount)
+        #else
+            // In SPM we're calling this functions out of the scope of the normal binary that it's
+            // being built, so *self* in this scope would be the SPM executable instead of the Fastfile
+            // that we'd normally expect.
+            let methodList = class_copyMethodList(type(of: fastfileInstance!), &methodCount)
+        #endif
+        for i in 0 ..< Int(methodCount) {
+            let selName = sel_getName(method_getName(methodList![i]))
+            let name = String(cString: selName)
+            let lowercasedName = name.lowercased()
+            if lowercasedName.hasSuffix("lane") || lowercasedName.hasSuffix("lanewithoptions:") {
+                lanes.append(name)
+            }
+        }
+        return lanes
+    }
+
+    public static var lanes: [String: String] {
+        var laneToMethodName: [String: String] = [:]
+        laneFunctionNames.forEach { name in
+            let lowercasedName = name.lowercased()
+            if lowercasedName.hasSuffix("lane") {
+                laneToMethodName[lowercasedName] = name
+                let lowercasedNameNoLane = trimLaneFromName(laneName: lowercasedName)
+                laneToMethodName[lowercasedNameNoLane] = name
+            } else if lowercasedName.hasSuffix("lanewithoptions:") {
+                let lowercasedNameNoOptions = trimLaneWithOptionsFromName(laneName: lowercasedName)
+                laneToMethodName[lowercasedNameNoOptions] = name
+                let lowercasedNameNoLane = trimLaneFromName(laneName: lowercasedNameNoOptions)
+                laneToMethodName[lowercasedNameNoLane] = name
+            }
+        }
+
+        return laneToMethodName
+    }
+
+    public static func loadFastfile() {
+        if fastfileInstance == nil {
+            let fastfileType: AnyObject.Type = NSClassFromString(className())!
+            let fastfileAsNSObjectType: NSObject.Type = fastfileType as! NSObject.Type
+            let currentFastfileInstance: Fastfile? = fastfileAsNSObjectType.init() as? Fastfile
+            fastfileInstance = currentFastfileInstance
+        }
+    }
+
+    public static func runLane(from fastfile: LaneFile?, named lane: String, with parameters: [String: String]) -> Bool {
+        log(message: "Running lane: \(lane)")
+        #if !SWIFT_PACKAGE
+            // When not in SPM environment, we load the Fastfile from its `className()`.
+            loadFastfile()
+            guard let fastfileInstance = fastfileInstance as? Fastfile else {
+                let message = "Unable to instantiate class named: \(className())"
+                log(message: message)
+                fatalError(message)
+            }
+        #else
+            // When in SPM environment, we can't load the Fastfile from its `className()` because the executable is in
+            // another scope, so `className()` won't be the expected Fastfile. Instead, we load the Fastfile as a Lanefile
+            // in a static way, by parameter.
+            guard let fastfileInstance = fastfile else {
+                log(message: "Found nil instance of fastfile")
+                preconditionFailure()
+            }
+            self.fastfileInstance = fastfileInstance
+        #endif
+        let currentLanes = lanes
+        let lowerCasedLaneRequested = lane.lowercased()
+
+        guard let laneMethod = currentLanes[lowerCasedLaneRequested] else {
+            let laneNames = laneFunctionNames.map { laneFuctionName in
+                if laneFuctionName.hasSuffix("lanewithoptions:") {
+                    return trimLaneWithOptionsFromName(laneName: laneFuctionName)
+                } else {
+                    return trimLaneFromName(laneName: laneFuctionName)
+                }
+            }.joined(separator: ", ")
+
+            let message = "[!] Could not find lane '\(lane)'. Available lanes: \(laneNames)"
+            log(message: message)
+
+            let shutdownCommand = ControlCommand(commandType: .cancel(cancelReason: .clientError), message: message)
+            _ = runner.executeCommand(shutdownCommand)
+            return false
+        }
+
+        // Call all methods that need to be called before we start calling lanes.
+        fastfileInstance.beforeAll(with: lane)
+
+        // We need to catch all possible errors here and display a nice message.
+        _ = fastfileInstance.perform(NSSelectorFromString(laneMethod), with: parameters)
+
+        // Call only on success.
+        if !LaneFile.onErrorCalled.contains(lane) {
+            fastfileInstance.afterAll(with: lane)
+        }
+
+        log(message: "Done running lane: \(lane) 🚀")
+        return true
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.2]

data/fastlane/swift/MainProcess.swift

@@ -0,0 +1,79 @@
+// MainProcess.swift
+// Copyright (c) 2023 FastlaneTools
+
+//
+//  ** NOTE **
+//  This file is provided by fastlane and WILL be overwritten in future updates
+//  If you want to add extra functionality to this project, create a new file in a
+//  new group so that it won't be marked for upgrade
+//
+
+import Foundation
+#if canImport(SwiftShell)
+    import SwiftShell
+#endif
+
+let argumentProcessor = ArgumentProcessor(args: CommandLine.arguments)
+let timeout = argumentProcessor.commandTimeout
+
+class MainProcess {
+    var doneRunningLane = false
+    var thread: Thread!
+    #if SWIFT_PACKAGE
+        var lastPrintDate = Date.distantFuture
+        var timeBetweenPrints = Int.min
+        var rubySocketCommand: AsyncCommand!
+    #endif
+
+    @objc func connectToFastlaneAndRunLane(_ fastfile: LaneFile?) {
+        runner.startSocketThread(port: argumentProcessor.port)
+
+        let completedRun = Fastfile.runLane(from: fastfile, named: argumentProcessor.currentLane, with: argumentProcessor.laneParameters())
+        if completedRun {
+            runner.disconnectFromFastlaneProcess()
+        }
+
+        doneRunningLane = true
+    }
+
+    func startFastlaneThread(with fastFile: LaneFile?) {
+        #if !SWIFT_PACKAGE
+            thread = Thread(target: self, selector: #selector(connectToFastlaneAndRunLane), object: nil)
+        #else
+            thread = Thread(target: self, selector: #selector(connectToFastlaneAndRunLane), object: fastFile)
+        #endif
+        thread.name = "worker thread"
+        #if SWIFT_PACKAGE
+            let PATH = run("/bin/bash", "-c", "-l", "eval $(/usr/libexec/path_helper -s) ; echo $PATH").stdout
+            main.env["PATH"] = PATH
+            let path = main.run(bash: "which fastlane").stdout
+            let pids = main.run("lsof", "-t", "-i", ":\(argumentProcessor.port)").stdout.split(separator: "\n")
+            pids.forEach { main.run("kill", "-9", $0) }
+            rubySocketCommand = main.runAsync(path, "socket_server", "-c", argumentProcessor.commandTimeout, "-p", argumentProcessor.port)
+            lastPrintDate = Date()
+            rubySocketCommand.stderror.onStringOutput { print($0) }
+            rubySocketCommand.stdout.onStringOutput { stdout in
+                print(stdout)
+                self.timeBetweenPrints = Int(self.lastPrintDate.timeIntervalSinceNow)
+            }
+
+            // swiftformat:disable:next redundantSelf
+            _ = Runner.waitWithPolling(self.timeBetweenPrints, toEventually: { $0 > 5 }, timeout: 10)
+            thread.start()
+        #endif
+    }
+}
+
+public class Main {
+    let process = MainProcess()
+
+    public init() {}
+
+    public func run(with fastFile: LaneFile?) {
+        process.startFastlaneThread(with: fastFile)
+
+        while !process.doneRunningLane, RunLoop.current.run(mode: RunLoopMode.defaultRunLoopMode, before: Date(timeIntervalSinceNow: 2)) {
+            // no op
+        }
+    }
+}

data/fastlane/swift/Matchfile.swift

@@ -0,0 +1,20 @@
+// Matchfile.swift
+// Copyright (c) 2023 FastlaneTools
+
+// This class is automatically included in FastlaneRunner during build
+
+// This autogenerated file will be overwritten or replaced during build time, or when you initialize `match`
+//
+//  ** NOTE **
+//  This file is provided by fastlane and WILL be overwritten in future updates
+//  If you want to add extra functionality to this project, create a new file in a
+//  new group so that it won't be marked for upgrade
+//
+
+public class Matchfile: MatchfileProtocol {
+    // If you want to enable `match`, run `fastlane match init`
+    // After, this file will be replaced with a custom implementation that contains values you supplied
+    // during the `init` process, and you won't see this message
+}
+
+// Generated with fastlane 2.212.1

data/fastlane/swift/MatchfileProtocol.swift

@@ -0,0 +1,211 @@
+// MatchfileProtocol.swift
+// Copyright (c) 2023 FastlaneTools
+
+public protocol MatchfileProtocol: AnyObject {
+    /// Define the profile type, can be appstore, adhoc, development, enterprise, developer_id, mac_installer_distribution, developer_id_installer
+    var type: String { get }
+
+    /// Create additional cert types needed for macOS installers (valid values: mac_installer_distribution, developer_id_installer)
+    var additionalCertTypes: [String]? { get }
+
+    /// Only fetch existing certificates and profiles, don't generate new ones
+    var readonly: Bool { get }
+
+    /// Create a certificate type for Xcode 11 and later (Apple Development or Apple Distribution)
+    var generateAppleCerts: Bool { get }
+
+    /// Skip syncing provisioning profiles
+    var skipProvisioningProfiles: Bool { get }
+
+    /// The bundle identifier(s) of your app (comma-separated string or array of strings)
+    var appIdentifier: [String] { get }
+
+    /// Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)
+    var apiKeyPath: String? { get }
+
+    /// Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-hash-option)
+    var apiKey: [String: Any]? { get }
+
+    /// Your Apple ID Username
+    var username: String? { get }
+
+    /// The ID of your Developer Portal team if you're in multiple teams
+    var teamId: String? { get }
+
+    /// The name of your Developer Portal team if you're in multiple teams
+    var teamName: String? { get }
+
+    /// Define where you want to store your certificates
+    var storageMode: String { get }
+
+    /// URL to the git repo containing all the certificates
+    var gitUrl: String { get }
+
+    /// Specific git branch to use
+    var gitBranch: String { get }
+
+    /// git user full name to commit
+    var gitFullName: String? { get }
+
+    /// git user email to commit
+    var gitUserEmail: String? { get }
+
+    /// Make a shallow clone of the repository (truncate the history to 1 revision)
+    var shallowClone: Bool { get }
+
+    /// Clone just the branch specified, instead of the whole repo. This requires that the branch already exists. Otherwise the command will fail
+    var cloneBranchDirectly: Bool { get }
+
+    /// Use a basic authorization header to access the git repo (e.g.: access via HTTPS, GitHub Actions, etc), usually a string in Base64
+    var gitBasicAuthorization: String? { get }
+
+    /// Use a bearer authorization header to access the git repo (e.g.: access to an Azure DevOps repository), usually a string in Base64
+    var gitBearerAuthorization: String? { get }
+
+    /// Use a private key to access the git repo (e.g.: access to GitHub repository via Deploy keys), usually a id_rsa named file or the contents hereof
+    var gitPrivateKey: String? { get }
+
+    /// Name of the Google Cloud Storage bucket to use
+    var googleCloudBucketName: String? { get }
+
+    /// Path to the gc_keys.json file
+    var googleCloudKeysFile: String? { get }
+
+    /// ID of the Google Cloud project to use for authentication
+    var googleCloudProjectId: String? { get }
+
+    /// Skips confirming to use the system google account
+    var skipGoogleCloudAccountConfirmation: Bool { get }
+
+    /// Name of the S3 region
+    var s3Region: String? { get }
+
+    /// S3 access key
+    var s3AccessKey: String? { get }
+
+    /// S3 secret access key
+    var s3SecretAccessKey: String? { get }
+
+    /// Name of the S3 bucket
+    var s3Bucket: String? { get }
+
+    /// Prefix to be used on all objects uploaded to S3
+    var s3ObjectPrefix: String? { get }
+
+    /// GitLab Project Path (i.e. 'gitlab-org/gitlab')
+    var gitlabProject: String? { get }
+
+    /// Keychain the items should be imported to
+    var keychainName: String { get }
+
+    /// This might be required the first time you access certificates on a new mac. For the login/default keychain this is your macOS account password
+    var keychainPassword: String? { get }
+
+    /// Renew the provisioning profiles every time you run match
+    var force: Bool { get }
+
+    /// Renew the provisioning profiles if the device count on the developer portal has changed. Ignored for profile types 'appstore' and 'developer_id'
+    var forceForNewDevices: Bool { get }
+
+    /// Include Apple Silicon Mac devices in provisioning profiles for iOS/iPadOS apps
+    var includeMacInProfiles: Bool { get }
+
+    /// Include all matching certificates in the provisioning profile. Works only for the 'development' provisioning profile type
+    var includeAllCertificates: Bool { get }
+
+    /// Renew the provisioning profiles if the certificate count on the developer portal has changed. Works only for the 'development' provisioning profile type. Requires 'include_all_certificates' option to be 'true'
+    var forceForNewCertificates: Bool { get }
+
+    /// Disables confirmation prompts during nuke, answering them with yes
+    var skipConfirmation: Bool { get }
+
+    /// Remove certs from repository during nuke without revoking them on the developer portal
+    var safeRemoveCerts: Bool { get }
+
+    /// Skip generation of a README.md for the created git repository
+    var skipDocs: Bool { get }
+
+    /// Set the provisioning profile's platform to work with (i.e. ios, tvos, macos, catalyst)
+    var platform: String { get }
+
+    /// Enable this if you have the Mac Catalyst capability enabled and your project was created with Xcode 11.3 or earlier. Prepends 'maccatalyst.' to the app identifier for the provisioning profile mapping
+    var deriveCatalystAppIdentifier: Bool { get }
+
+    /// The name of provisioning profile template. If the developer account has provisioning profile templates (aka: custom entitlements), the template name can be found by inspecting the Entitlements drop-down while creating/editing a provisioning profile (e.g. "Apple Pay Pass Suppression Development")
+    var templateName: String? { get }
+
+    /// A custom name for the provisioning profile. This will replace the default provisioning profile name if specified
+    var profileName: String? { get }
+
+    /// Should the command fail if it was about to create a duplicate of an existing provisioning profile. It can happen due to issues on Apple Developer Portal, when profile to be recreated was not properly deleted first
+    var failOnNameTaken: Bool { get }
+
+    /// Set to true if there is no access to Apple developer portal but there are certificates, keys and profiles provided. Only works with match import action
+    var skipCertificateMatching: Bool { get }
+
+    /// Path in which to export certificates, key and profile
+    var outputPath: String? { get }
+
+    /// Skips setting the partition list (which can sometimes take a long time). Setting the partition list is usually needed to prevent Xcode from prompting to allow a cert to be used for signing
+    var skipSetPartitionList: Bool { get }
+
+    /// Print out extra information and all commands
+    var verbose: Bool { get }
+}
+
+public extension MatchfileProtocol {
+    var type: String { return "development" }
+    var additionalCertTypes: [String]? { return nil }
+    var readonly: Bool { return false }
+    var generateAppleCerts: Bool { return true }
+    var skipProvisioningProfiles: Bool { return false }
+    var appIdentifier: [String] { return [] }
+    var apiKeyPath: String? { return nil }
+    var apiKey: [String: Any]? { return nil }
+    var username: String? { return nil }
+    var teamId: String? { return nil }
+    var teamName: String? { return nil }
+    var storageMode: String { return "git" }
+    var gitUrl: String { return "" }
+    var gitBranch: String { return "master" }
+    var gitFullName: String? { return nil }
+    var gitUserEmail: String? { return nil }
+    var shallowClone: Bool { return false }
+    var cloneBranchDirectly: Bool { return false }
+    var gitBasicAuthorization: String? { return nil }
+    var gitBearerAuthorization: String? { return nil }
+    var gitPrivateKey: String? { return nil }
+    var googleCloudBucketName: String? { return nil }
+    var googleCloudKeysFile: String? { return nil }
+    var googleCloudProjectId: String? { return nil }
+    var skipGoogleCloudAccountConfirmation: Bool { return false }
+    var s3Region: String? { return nil }
+    var s3AccessKey: String? { return nil }
+    var s3SecretAccessKey: String? { return nil }
+    var s3Bucket: String? { return nil }
+    var s3ObjectPrefix: String? { return nil }
+    var gitlabProject: String? { return nil }
+    var keychainName: String { return "login.keychain" }
+    var keychainPassword: String? { return nil }
+    var force: Bool { return false }
+    var forceForNewDevices: Bool { return false }
+    var includeMacInProfiles: Bool { return false }
+    var includeAllCertificates: Bool { return false }
+    var forceForNewCertificates: Bool { return false }
+    var skipConfirmation: Bool { return false }
+    var safeRemoveCerts: Bool { return false }
+    var skipDocs: Bool { return false }
+    var platform: String { return "ios" }
+    var deriveCatalystAppIdentifier: Bool { return false }
+    var templateName: String? { return nil }
+    var profileName: String? { return nil }
+    var failOnNameTaken: Bool { return false }
+    var skipCertificateMatching: Bool { return false }
+    var outputPath: String? { return nil }
+    var skipSetPartitionList: Bool { return false }
+    var verbose: Bool { return false }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.111]